java 最小覆盖子串

牛客题目链接

1. 题目考点

1. 用一个数组来哈希映射一个字符串（典型，a[ch]++）
2. 用双指针来表示一个区间（滑动窗口）
3. 左右指针交替向右移动，且不回溯右指针（O(n)）

2. 考点解析

1. 数组哈希字符串 + 双指针滑动窗口（有三个关键地方）

public String minWindow (String S, String T) {
    // write code here
    // 关键：数组哈希映射字符串
    int[] needs = new int[128];
    int[] window = new int[128];
    
    for (int i = 0; i < T.length(); i++)
        needs[T.charAt(i)]++;
    
    int left = 0, right = 0;
    String res = "";
    // cnt 表示属于 T 的字符的个数
    // 关键：S 可能等于 T，所以 minLen 的初识值为 S 的长度 + 1
    int cnt = 0, minLen = S.length() + 1;
    while (right < S.length()) {
        char ch = S.charAt(right);
        window[ch]++;
        // 关键：needs[ch] >= window[ch]，因为 ch 在 T 中可能重复，也就是 needs[ch] 可能 > 1 的
        if (needs[ch] > 0 && needs[ch] >= window[ch]) 
            cnt += 1;
        
        // 当区间刚好包含 T 中所有字符时，左指针开始移动，直到刚好不包含 T 中所有字符
        while (cnt == T.length()) {
            ch = S.charAt(left);
            // 关键：need[ch] >= window[ch]，也可以 == 
            if (needs[ch] > 0 && needs[ch] == window[ch])
                cnt -= 1;
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                res = S.substring(left, right + 1);
            }
            window[ch] -= 1;
            left += 1;
        }
        right += 1;
    }
    return res;
}

2. leecode 官方解法一：在 S 中挑选目标字符的过程，加法逻辑

public String minWindow (String S, String T) {
    // write code here
    if (S == null || T == null) return "";
    int sLen = S.length();
    int tLen = T.length();
    if (sLen == 0 || tLen == 0 || sLen < tLen)
        return "";
    
    int[] winFreq = new int[128];
    int[] tFreq = new int[128];
    for (int i = 0; i < tLen; i++)
        tFreq[T.charAt(i)]++;
    
    int cnt = 0, minLen = sLen + 1;
    int left = 0, right = 0, begin = 0;
    
    while (right < sLen) {
        char ch = S.charAt(right);
        // 忽略不在 T 中的字符
        if (tFreq[ch] == 0) {
            right++;
            continue;
        }
        // 某个字符出现次数未满
        if (winFreq[ch] < tFreq[ch])
            cnt++;
        winFreq[ch]++;
        // 先走 right
        right++;
        
        while (cnt == tLen) {
        	// 更新最小长度，right 先走，所以不需要 + 1
            if (right - left < minLen) {
                minLen = right - left;
                begin = left;
            }
            ch = S.charAt(left);
            // 同样忽略不在 T 中的字符
            if (tFreq[ch] == 0) {
                left++;
                continue;
            }
            // 如果某个字符出现次数刚好相等
            if (tFreq[ch] == winFreq[ch])
                cnt--;
            winFreq[ch]--;
            left++;
        }
    }
    
    if (minLen == sLen + 1) return "";
    return S.substring(begin, begin+minLen);
}

3. leetcode 官网解法二：减法逻辑

public String minWindow (String S, String T) {
    // write code here
    if (S == null || T == null || S == "" || 
        T == "" || S.length() < T.length()) return "";
    
    int sLen = S.length();
    int tLen = T.length();
    
    int[] tFreq = new int[128];
    for (int i = 0; i < tLen; i++)
        tFreq[T.charAt(i)]++;
    
    // 减法逻辑 cnt = tLen
    int cnt = tLen, minLen = sLen + 1;
    int left = 0, right = 0, begin = 0;
    
    while (right < sLen) {
        char ch = S.charAt(right);
        if (tFreq[ch] > 0)
            cnt--;
        // 巧妙：不在 T 中的字符，值 < 0，排除它
        tFreq[ch]--;
        right++;
        
        while (cnt == 0) {
            if (right - left < minLen) {
                minLen = right - left;
                begin = left;
            }
            ch = S.charAt(left);
            // 0 表示该字符属于 T
            if (tFreq[ch] == 0)
                cnt++;
            tFreq[ch]++;
            left++;
        }
    }
    
    if (minLen == sLen + 1) return "";
    return S.substring(begin, begin+minLen);
}