算法 -- 滑动窗口思想

 

滑动窗口就是在一个数组上设置一个left指针和right指针。

整体框架如下，问题的关键 缩小窗口的时机 

int left = 0;
int right = 0;

while (right < s.length()) {`
    // 增大窗口
    window.add(s[right]);
    right++;
    
    while (window 满足一定条件) {
        // 缩小窗口
        window.remove(s[left]);
        left++;
    }
}

LeetCode438

题目描述

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
示例 1:

输入:
s: "cbaebabacd" p: "abc"

输出:
[0, 6]

解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。
 示例 2:

输入:
s: "abab" p: "ab"

输出:
[0, 1, 2]

解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

解题思路

这道题要求窗口内的字符串严格是目标串字母异位词。假如所求是abc

那么如果当前字符不合法（有两种情况）：

    1 当前right对应的字符不在目标串中 abe

    2 当前right对应的字符出现的次数超过了目标串中要求 aba

  对于1，就是当前字符在目标串中的次数为0，所以这两种情况其实可以合并成2 。

此时，当前这个窗口已经不可能是答案之一了，那就要left右移，直到这个不合法的字符变得合法了

    对于情况1，就需要 它本身移除窗口了 这个时候其实left和right重新重合 （都移到了e后边的那个元素）

    对于情况2，就需要 在它之前移除掉一个同样的字符 （left在b上，前边的a出窗口）

因为每当出现不合法字符的时候就进去小while去处理，那么到达if判断的时候的窗口肯定是合法的，所以当窗口长度是字符串长度的时候，就是答案之一了，加入到res。

package leetcode_n;

import java.util.ArrayList;
import java.util.List;


public class LeetCode438_findAnagrams2  {
    public static void main(String[] args) {
        String s = "cbfebabacd" ;
        String p =  "abc";
        System.out.println(new LeetCode438_findAnagrams2().findAnagrams(s,p));
    }
    /*
    滑动窗口的思想：如果当前窗口包含所求串（如果是严格匹配，那要求当前窗口就是所求串。
    如果是窗口中含有所求，如leetcode76,那可以是包含所求）
    本题，要求窗口内就是所求，不能有多余元素，比如要求abc，如果当前窗口已经有两个a，那就要一直left++，直到只剩一个a
    再比如要求abc，而当前是abe，那left++，直到e出窗口了，前边的ab也不能要了，因为要求滑动窗口就是所求串！
    当前的合法窗口要么是所求的一部分，就是继续扩展有可能成为答案，比如当前是ab，那就继续右移，只要能一直右移，就说明没遇到不合法的元素
    那如果当前窗口字符串长度==所求字符串长度了，那当前窗口就是最终窗口了，可加入到res
    然后继续移动窗口
     */
    public List<Integer> findAnagrams(String s, String p) {
        char[] arrayS = s.toCharArray();
        char[] arrayP = p.toCharArray();
        int[] needs = new int[26]; //统计目标串每个字符的出现次数
        for (int i = 0; i < arrayP.length; i++) {
            int index = arrayP[i] - 'a';
            needs[index]++;
        }
        int[] windows = new int[26];
        List<Integer> res = new ArrayList<>();
        int left = 0;
        int right = 0;
        while (right < arrayS.length){
            int curRightIndex = arrayS[right] - 'a'; //当前字符对应的索引
            windows[curRightIndex]++;
            right++; //为下一次while做准备

            //如果并不需要当前字符,left++可能删除很多，直到curIndex这个字符的数量满足目标串数量要求
            while (windows[curRightIndex] > needs[curRightIndex]){
                int delLeftIndex = arrayS[left] - 'a';
                windows[delLeftIndex]--;
                left++;
            }

            if (right - left == arrayP.length){
                res.add(left);
            }

        }
        return res;
    }
}

LeetCode76

题目描述

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。

示例：

输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
说明：

如果 S 中不存这样的子串，则返回空字符串 ""。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

解题思路

当窗口中满足条件的key没有达到要求时，就right++

当满足了，就尝试left++，看能不能在缩小窗口的条件下依然满足

package leetcode_1;

import java.util.HashMap;


public class LeetCode76_minWindow {
    public static void main(String[] args) {
        String S = new String("ADOBECODEBANC");
        String T = new String("ABC");
        System.out.println(new LeetCode76_minWindow().minWindow(S,T));

    }
    public String minWindow(String s, String t) {
        char[] arrayS = s.toCharArray();
        char[] arrayT = t.toCharArray();

        HashMap<Character,Integer> mapT = new HashMap<>();
        HashMap<Character,Integer> mapS =new HashMap<>();
        int sum = 0;//统计key的个数

        for (int i = 0; i < arrayT.length; i++) {  //统计目标串的字符情况 可以用数组模拟hashmap也可以直接用hashmap
            char key = arrayT[i];
            if (mapT.containsKey(key)){
                mapT.put(key,mapT.get(key) + 1);
            }else {
                mapT.put(key,1);
                mapS.put(key,0); //窗口中key对于的value都先初始化成0
                sum ++;
            }
        }

        String res = "";
        int left = 0;
        int right = 0;
        int count = 0;//记录当前窗口内有几个key满足目标串了
        while (right < arrayS.length){
            char curRightKey = arrayS[right];
            //System.out.println("当前right  " + curRightKey);
            if (mapS.containsKey(curRightKey)){
                mapS.put(curRightKey,mapS.get(curRightKey) + 1);
                if (mapS.get(curRightKey).equals(mapT.get(curRightKey))){ //当有一个key达到目标数量了 ！！！！！！！！interger比较用equals 超过127用==就错了！！！！！
                    count++;
                }
            }

            //System.out.println("count  " + count);
            right++;

            while (count == sum){ //当所有key都满足目标数量了 left右移 尝试缩小窗口找最小串
                int curWinLength = right - left;  //[left,right)
                if (res.equals("") || res.length() >  curWinLength ){
                    res = s.substring(left,right);
                    //System.out.println("res  " + res);
                }
                char curLeftKey = arrayS[left];
                //System.out.println("当前left  " + curLeftKey);
                //如果当前的key存在在目标key中，则value减一，如果是关键的key (即减之前正好相等，减之后小于) 此时count--
                if (mapT.containsKey(curLeftKey)){
                    int value = mapS.get(curLeftKey);
                    if (value == mapT.get(curLeftKey)){
                        count--;
                    }
                    mapS.put(curLeftKey,value - 1);
                }
                left++;
            }
        }
        return res;
    }
}