3090. 每个字符最多出现两次的最长子字符串

输入：s = "bcbbbcba"
输出：4
解释：满足条件的最长子字符串是 "bcbb"，每个字符最多出现两次，长度为 4

输入：s = "aaaa"
输出：2
解释：满足条件的最长子字符串是 "aa"，长度为 2

s = "bcbbbcba"

right = 0, 进入 b：{b:1}，合法，ans = 1
right = 1, 进入 c：{b:1, c:1}，合法，ans = 2
right = 2, 进入 b：{b:2, c:1}，合法，ans = 3
right = 3, 进入 b：{b:3, c:1}，b 超过 2！
  移出 s[0]=b：{b:2, c:1}，合法，left = 1，ans = 3
right = 4, 进入 b：{b:3, c:1}，b 超过 2！
  移出 s[1]=c：{b:3}，还是不合法
  移出 s[2]=b：{b:2}，合法，left = 3，ans = max(3, 4-3+1) = 3
  等等，此时窗口是 s[3..4] = "bb"，长度 2
right = 5, 进入 c：{b:2, c:1}，合法，ans = max(3, 5-3+1) = 3
right = 6, 进入 b：{b:3, c:1}，b 超过 2！
  移出 s[3]=b：{b:2, c:1}，合法，left = 4
right = 7, 进入 a：{b:2, c:1, a:1}，合法，ans = max(3, 7-4+1) = 4

# 第 3 题：每个字符最多出现 1 次
while count[ch] > 1:
    ...

# 第 3090 题：每个字符最多出现 2 次
while count[ch] > 2:
    ...

class Solution:
    def maximumLengthSubstring(self, s: str) -> int:
        count = {}
        left = 0
        ans = 0

        for right, ch in enumerate(s):
            count[ch] = count.get(ch, 0) + 1

            while count[ch] > 2:
                left_ch = s[left]
                count[left_ch] -= 1
                left += 1

            ans = max(ans, right - left + 1)

        return ans

impl Solution {
    pub fn maximum_length_substring(s: String) -> i32 {
        let bytes = s.as_bytes();
        let mut count = [0u32; 26];
        let mut left = 0;
        let mut ans = 0;

        for right in 0..bytes.len() {
            let ch = (bytes[right] - b'a') as usize;
            count[ch] += 1;

            while count[ch] > 2 {
                count[(bytes[left] - b'a') as usize] -= 1;
                left += 1;
            }

            ans = ans.max(right - left + 1);
        }

        ans as i32
    }
}