算法-滑动窗口

算法逻辑：

int left = 0, right = 0;
while (right < s.size()) {
	// 增⼤窗⼝
	window.add(s[right]);
	right++;
	while (window needs shrink) {
		// 缩⼩窗⼝
		window.remove(s[left]);
		left++;
	}
}

算法思路：

1. 我们在字符串 S 中使⽤双指针中的左右指针技巧，初始化 left = right = 0，把索引左闭右开区间[left, right)
   称为⼀个窗⼝。
2. 我们先不断地增加 right 指针扩⼤窗口 [left, right)，直到窗口中的字符串符合要求（包含了 T 中的所有字符）。
3. 此时，我们停止增加 right，转⽽不断增加 left 指针缩小窗口 [left, right)，直到窗口中的字符串不再符合要求（不包含T 中的所有字符了）。同时，每次增加 left，我们都要更新⼀轮结果。
4. 重复第 2 和第 3 步，直到 right 到达字符串 S 的尽头。

思路：第 2 步相当于在寻找⼀个可行解，然后第 3 步在优化这个可行解，最终找到最优解，也就是最短的覆盖子串。左右指针轮流前进，窗⼝大小增增减减，窗口不断向右滑动，这就是滑动窗口这个名字的来历。

算法的时间复杂度是 O(N)，⽐字符串暴力算法要高效得多。

总结框架：

/* 滑动窗⼝算法框架 */
void slidingWindow(string s, string t) {
	Map<Character, Integer> need = new HashMap<>();
	Map<Character, Integer> window = new HashMap<>();
	// need 初始化
    for (int i = 0; i < t.length(); i++) {
        char c = t.charAt(i);
        need.put(c, need.getOrDefault(c, 0) + 1);
    }
	int left = 0, right = 0;
	int valid = 0; 
	while (right < s.length()) {
	// 移入窗口的元素
    char c = s.charAt(right);
    // 右移窗口
    right++;
	// 进⾏窗⼝内数据的⼀系列更新
	...
	/*** debug 输出的位置 ***/
	System.out.println("window: [" +  left + ", "+ right + ")");
	/********************/
	
	// 判断左侧窗⼝是否要收缩
	while (window needs shrink) {
		// d 是将移出窗⼝的字符
		char d = s.charAt(left);
		// 左移窗⼝
		left++;
		// 进⾏窗⼝内数据的⼀系列更新
		...
		}
	}
}

图示演示：

• 初始状态：

• 增加 right，直到窗⼝ [left, right] 包含了 T 中所有字符：

• 现在开始增加 left，缩⼩窗⼝ [left, right]：

• 直到窗⼝中的字符串不再符合要求，left 不再继续移动：

• 重复上述过程，先移动 right，再移动 left…… 直到 right 指针到达字符串 S 的末端，算法结束。

leetcode 76. 最小覆盖子串

public String minWindow(String s, String t) {
	Map<Character, Integer> need = new HashMap<>();
	Map<Character, Integer> window = new HashMap<>();
	// need 初始化
	for (int i = 0; i < t.length(); i++) {
	    char c = t.charAt(i);
	    need.put(c, need.getOrDefault(c, 0) + 1);
	}
	int left = 0;
	int right = 0;
	int valid = 0;
	// 记录最小覆盖子串的起始索引及长度
	int start = 0, len = Integer.MAX_VALUE;
	while(right < s.length()) {
	    // 移入窗口的元素
	    char c = s.charAt(right);
	    right++;
	    // 改变 window 窗口
	    if (need.containsKey(c)) {
	        window.put(c, window.getOrDefault(c, 0) + 1);
	        if (need.get(c).equals(window.get(c))) {
	            valid++;
	        }
	    }
	    // 收缩窗口
	    while(valid == need.size()) {
	        // 更新最小覆盖子串
	        if (right - left < len) {
	            start = left;
	            len = right - left;
	        }
	        // 移出窗口的元素
	        char d = s.charAt(left);
	        left++;
	        // 改变 window 窗口
	        if (need.containsKey(d)) {
	            if (need.get(d).equals(window.get(d))) {
	                valid--;
	            }
	            window.put(d, window.get(d) - 1);
	        }
	    }
	}
	// 返回最小覆盖子串
	return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
}

当 valid == need.size() 时，说明 T 中所有字符已经被覆盖，已经得到⼀个可行的覆盖⼦串，现在应该开始收缩窗⼝了，以便得到最小覆盖子串。

更新最小覆盖子串应该在每次收缩窗口前，以保证能更新覆盖子串的大小。

leetcode 567. 字符串的排列

public boolean checkInclusion(String s1, String s2) {
	Map<Character, Integer> need = new HashMap<>();
	 Map<Character, Integer> window = new HashMap<>();
	 // 初始化 need
	 for (int i = 0; i < s1.length(); i++) {
	     char c = s1.charAt(i);
	     need.put(c, need.getOrDefault(c, 0) + 1);
	 }
	 int left = 0, right = 0;
	 int valid = 0;
	 while (right < s2.length()) {
	     char c = s2.charAt(right);
	     right++;
	     // 进⾏窗⼝内数据的⼀系列更新
	     if (need.containsKey(c)) {
	         window.put(c, window.getOrDefault(c, 0) + 1);
	         if (window.get(c).equals(need.get(c))) {
	             valid++;
	         }
	     }
	     // 判断左侧窗口是否要收缩
	     while (right - left >= s1.length()) {
	         if (valid == need.size()) {
	             return true;
	         }
	         char d = s2.charAt(left);
	         left++;
	         // 进⾏窗⼝内数据的⼀系列更新
	         if (need.containsKey(d)) {
	             if (window.get(d).equals(need.get(d))) {
	                 valid--;
	             }
	             window.put(d, window.get(d) - 1);
	         }
	     }
	 }
	 return false;
}

移动 left 缩小窗口的时机是窗口大小大于 s1.length() 时，因为排列的长度应该与子串长度⼀样。

当上述条件下又 valid == need.size() ，则说明正好所有元素都已满足，显然是满足条件，即元素个数正好等于s1长度的情况，直接返回 true。

leetcode 438. 找到字符串中所有字母异位词

public List<Integer> findAnagrams(String s, String p) {
    Map<Character, Integer> need = new HashMap<>();
    Map<Character, Integer> window = new HashMap<>();
    for (int i = 0; i < p.length(); i++) {
        char c = p.charAt(i);
        need.put(c, need.getOrDefault(c, 0) + 1);
    }
    int left = 0, right = 0;
    int valid = 0;
    List<Integer> res = new ArrayList<>();
    while (right < s.length()) {
        char c = s.charAt(right);
        right++;
        // 进⾏窗⼝内数据的⼀系列更新
        if (need.containsKey(c)) {
            window.put(c, window.getOrDefault(c, 0) + 1);
            if (need.get(c).equals(window.get(c))) {
                valid++;
            }
        }
        // 判断左侧是否要收缩
        while (right - left >= p.length()) {
            // 当窗⼝符合条件时，把起始索引加⼊ res
            if (valid == need.size()) {
                res.add(left);
            }
            char d = s.charAt(left);
            left++;
            // 进⾏窗⼝内数据的⼀系列更新
            if (need.containsKey(d)) {
                if (need.get(d).equals(window.get(d))) {
                    valid--;
                }
                window.put(d, window.get(d) - 1);
            }
        }
    }
    return res;
}

leetcode 3. 无重复字符的最长子串

public int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> window = new HashMap<>();
    int left = 0, right = 0;
    // 记录结果
    int res = 0;
    while (right < s.length()) {
        char c = s.charAt(right);
        right++;
        // 进⾏窗⼝内数据的⼀系列更新
        window.put(c, window.getOrDefault(c, 0) + 1);
        // 判断左侧是否要收缩
        while (window.get(c) > 1) {
            char d = s.charAt(left);
            left++;
            // 进⾏窗⼝内数据的⼀系列更新
            window.put(d, window.get(d) - 1);
        }
        // 更新答案
        res = Math.max(res, right - left);
    }
    return res;
}

当 window.get ( c ) > 1 时说明该元素出现已不止一次，即要收缩窗口。

更新答案要在 外层循环 中，每次更新为最长子串。