leetcode1371

class Solution {
    public int findTheLongestSubstring(String s) {
        int n = s.length();
        Map<Character, Integer> map = new HashMap<>();
        map.put('a', 0);
        map.put('e', 0);
        map.put('i', 0);
        map.put('o', 0);
        map.put('u', 0);
        int l = 0, maxlen = 0;
        for (int r = 0; r < n; r++) {
            char curr = s.charAt(r);
            if (map.containsKey(curr)) {
                map.put(curr, map.get(curr) + 1);
            }
            Map<Character, Integer> temp = new HashMap<>();

            temp.put('a', map.get('a'));
            temp.put('e', map.get('e'));
            temp.put('i', map.get('i'));
            temp.put('o', map.get('o'));
            temp.put('u', map.get('u'));

            while (temp.get('a') % 2 == 1 || temp.get('e') % 2 == 1 || temp.get('i') % 2 == 1 || temp.get('o') % 2 == 1
                    || temp.get('u') % 2 == 1) {
                char left = s.charAt(l);
                if (temp.containsKey(left)) {
                    temp.put(left, temp.get(left) - 1);
                }
                l++;
            }
            maxlen = Math.max(maxlen, r - l + 1);
            l = 0;
        }
        return maxlen;
    }
}

参考：https://leetcode.com/problems/find-the-longest-substring-containing-vowels-in-even-counts/discuss/532958/Easy-Solution-Using-Sliding-Window-In-Java!

算法思路：滑动窗口。

分析：两层循环，外层确定右边界，内层确定左边界。

每次外层循环，都复制一份元音字母个数的字典放到temp中。判断当前状态是否存在某个元音字符的个数是奇数个。

　　如果存在这样的元音字符，则将左边界向右移动，一直到所有元音字符都是偶数个为止。此时找到一种解决方案，跳出循环。

计算此时的字串的长度，并更新最大长度字段maxlen。

可见这种解决方案的时间复杂度是O(n*n)，效率比较低。

在leetcode上的执行结果为：

第二种方案：

class Solution {
    public int findTheLongestSubstring(String s) {
        int res = 0 , cur = 0, n = s.length();
        HashMap<Integer, Integer> seen = new HashMap<>();
        seen.put(0, -1);
        for (int i = 0; i < n; ++i) {
            cur ^= 1 << ("aeiou".indexOf(s.charAt(i)) + 1 ) >> 1;
            seen.putIfAbsent(cur, i);
            res = Math.max(res, i - seen.get(cur));
        }
        return res;
    }
}

算法思路：位运算。

分析：这应该是本题的比较好的解决方案。

在leetcode上的执行结果：

与第一种方案对比，执行效率高了很多，但不太容易理解。