每个元音包含偶数次的最长子字符串

leetcode上的题目

要求

给你一个字符串 s ，请你返回满足以下条件的最长子字符串的长度：每个元音字母，即 ‘a’，‘e’，‘i’，‘o’，‘u’ ，在子字符串中都恰好出现了偶数次。

示例 1：

输入：s = "eleetminicoworoep"
输出：13
解释：最长子字符串是 "leetminicowor" ，它包含 e，i，o 各 2 个，以及 0 个 a，u 。

示例 2：

输入：s = "leetcodeisgreat"
输出：5
解释：最长子字符串是 "leetc" ，其中包含 2 个 e 。

示例 3：

输入：s = "bcbcbc"
输出：6
解释：这个示例中，字符串 "bcbcbc" 本身就是最长的，因为所有的元音 a，e，i，o，u 都出现了 0 次。

提示：

1 <= s.length <= 5 x 10^5
s 只包含小写英文字母。

我的算法

public static int findTheLongestSubstring(String s) {
	int f[]=new int[s.length()];
	for(int i=0;i<s.length();i++) {
		switch (s.charAt(i)) {
		case 'a':
			f[i]=1;
			break;
		case 'e':
			f[i]=2;
			break;
		case 'i':
			f[i]=3;
			break;
		case 'o':
			f[i]=4;
			break;
		case 'u':
			f[i]=5;
			break;
		default:
			f[i]=0;
			break;
		}
	}
	int res=0;
	boolean type;
	int state[]=new int[6]; //存储状态
	for(int i=0;i<f.length;i++) {
		init_state(state);
		type=true;
		for(int j=i;j<f.length;j++) {
			if(f[j]==0) {
				if(type&&res<j-i+1) {
//						System.out.println(i+"---"+j+"---"+res);
					res=j-i+1;
				}
				continue;
			}
			state[f[j]]++;
			if(Judge_state(state)) {
				if(res<j-i+1) {
//						System.out.println(i+"---"+j+"---"+res);
					res=j-i+1;
				}
				type=true;
			}
			else {
				type=false;
			}
				
		}
	}
	return res;
}

public static boolean Judge_state(int state[]) {
	for(int i=0;i<state.length;i++) {
		if(state[i]%2!=0)
			return false;
	}
	return true;
}

public static void init_state(int state[]) {
	for(int i=0;i<state.length;i++) {
		state[i]=0;
	}
}

时间复杂度O(n²),若s长度很大，需要很长时间的计算。

思路：

f 数组与s字符串每位对应：非aeiou的置为0，a置为1，e置为2，i置为3，o置为4，u置为5
然后开始遍历，依次从i开始，查找到末尾（即s.length()-1 ）。保存其中的最大子字符串长度，最后返回。
其中state数组用于存储aeiou出现的次数。只有都为偶数次才能更新最大长度。
type为标识。表明 i 到 j 的字符串中元音都出现偶数次。用于遍历是为非元音时更新最大长度。

看到的大佬算法

private static final String VOWELS = "aeiou";
public static int findTheLongestSubstring_1(String s) {
    Map<Integer, Integer> map = new HashMap<>();
    int size = s.length();
    int state = 0; // (00000)
    int maxSize = 0;
    map.putIfAbsent(0, -1);
    for (int i = 0; i < size; i ++){
        for (int k = 0; k < VOWELS.length(); k++){
            if (s.charAt(i) == VOWELS.charAt(k)){
                state ^= (1 << (VOWELS.length() - k - 1));
                break; 
            }
        }
        if (map.containsKey(state)){
            maxSize = Math.max(maxSize, i - map.get(state));
        }
        map.putIfAbsent(state, i);
    }

    return maxSize;
}

时间复杂度O(n)

个人理解：

它使用了异或（按位运算，相同为0，不同为1，来实现偶数次判断）
若 state 的值为0，说明当前 0 到 i 内出现的元音均为偶数次。
若不为0，则存在某个或者某几个元音为奇数次。此时可以通过map定位首次出现当前state值对应下标。通过将其排除，就可以使奇数次变为偶数次，从而满足要求。

思路和大佬的差不多，实现方式略微不同。

public int findTheLongestSubstring(String s) {
    int n = s.length();
    int[] pos = new int[1 << 5];
    Arrays.fill(pos, -1);
    int ans = 0, status = 0;
    pos[0] = 0;
    for (int i = 0; i < n; i++) {
        char ch = s.charAt(i);
        if (ch == 'a') {
            status ^= (1 << 0);
        } else if (ch == 'e') {
            status ^= (1 << 1);
        } else if (ch == 'i') {
            status ^= (1 << 2);
        } else if (ch == 'o') {
            status ^= (1 << 3);
        } else if (ch == 'u') {
            status ^= (1 << 4);
        }
        if (pos[status] >= 0) {
            ans = Math.max(ans, i + 1 - pos[status]);
        } else {
            pos[status] = i + 1;
        }
    }
    return ans;
}