滑動窗口算法 總結（附經典題目）

6.滑動窗口

求滿足一定條件的 連續子區間，子串一般用滑動窗口

模板

public slidingWindow(String s, String t){
    HashMap<Character,Integer> need,window;
    for(char c: t.toCharArray()){
        need.put(c,need.getOrDefault(c,0)+1);
    }
    int left right valid=0;
    while(right<s.length()){
        //當前字符
        char c=s.getCharAt(right);
        //增大右窗口
        right++;
        
        //進行窗口內數據的更新
        ...
       //判斷左窗口是夠需要收縮
        while(window needs shrink){
            char d=t.charAt(left);
            left++;
            //進行窗口數據的更新
            ...
        }
        
    }
}

最后返回原字符串的[left,right)

題目：長度最小的子數組

解法：

我們以該題為例

我們依次增大右邊界，直到滿足條件后，增大左邊界縮小區間，直到不滿足條件后再次增大右邊界......

時間復雜度O（N）

 public int minSubArrayLen(int target, int[] nums) {
      if(nums.length==0){
          return 0;
      }
      int left=0;
      int right=0;
      int sum=0;
      int result=Integer.MAX_VALUE;
      //通常主循環是以右邊界為判斷條件
      while(right<nums.length){
          sum=sum+nums[right];
          //滿足條件后開始增大左邊界
          while(sum>=target){
              result=Math.min(result,right-left+1);
              sum=sum-nums[left];
              left++;
          }
          right++;
      }
     // 如果沒有滿足條件的區間，返回0
      return result==Integer.MAX_VALUE? 0:result;

    }

題目：無重復字符最長子串

解法：

 public int lengthOfLongestSubstring(String s) { 
        if(s.length()==0){
            return 0;
        }
        //存儲已經訪問過的字符
        HashMap<Character,Integer> hashMap=new HashMap<>();
        int right=0;
        int left=0;
        int result=Integer.MIN_VALUE;

        while (right < s.length()) {
            char c=s.charAt(right);
           
            right++;
            hashMap.put(c,hashMap.getOrDefault(c,0)+1);

            //左邊界更新
            //這里要用equals,因為Integer類型比較的是地址（如果是[-127，128]內的數字，由於緩存存在，地址相同，此時equals和==無區別，但超過這個范圍地址就不同了）
            while(hashMap.get(c).equals(2)){
                
                char b=s.charAt(left);
                left++;
                hashMap.put(b,hashMap.get(b)-1);
            }
           result=Math.max(right-left,result);
        }
        
        return result;
    }

題目：字符串排列

解法

public boolean checkInclusion(String s1, String s2) {
        HashMap<Character,Integer> need=new HashMap<>();
        HashMap<Character,Integer> window=new HashMap<>();
        int right=0;
        int left=0;
        int valid=0;
        for(char c: s1.toCharArray()){
            need.put(c,need.getOrDefault(c,0)+1);
        }
        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(valid==need.size()){
                if(right-left==s1.length()){
                    return true;
                }
                char b=s2.charAt(left);
                left++;
                if (need.containsKey(b)) {
                if(window.get(b).equals(need.get(b))){
                    valid--;
                }
                window.put(b,window.getOrDefault(b,0)-1);
            }
            }
        }
        return false;
    }

題目：找到字符串中所有字母異位詞

解法：

public List<Integer> findAnagrams(String s, String p) {
          List<Integer> result=new ArrayList<>();
          HashMap<Character,Integer> need=new HashMap<>();
          HashMap<Character,Integer> window=new HashMap<>();
          for(char c:p.toCharArray()){
              need.put(c,need.getOrDefault(c,0)+1);
          }
          int right=0;
          int left=0;
          int valid=0;
          while(right<s.length()){
              char c=s.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(valid==need.size()){
                  if(right-left==p.length()){
                      result.add(left);
                  }
                  char b=s.charAt(left);
                  left++;
       
                  if(need.containsKey(b)){
                    //如果當前數目剛好夠，減一次就不夠了
                     if(window.get(b).equals(need.get(b))){
                          valid--;
                      }
                      window.put(b,window.getOrDefault(b,0)-1);
                     
                  }
              }            
          }
          return result;
    }

題目：最小覆蓋子串

解法：

class Solution {
    public String minWindow(String s, String t) {
        HashMap<Character, Integer> need = new HashMap<Character, Integer>();
        HashMap<Character, Integer> window = new HashMap<>();
        for (char c :  t.toCharArray()) need.put(c, need.getOrDefault(c, 0) + 1);

        int left = 0, right = 0;
        int valid = 0;
        // 記錄最小覆蓋字串的起始索引及長度
        int start = 0, len = Integer.MAX_VALUE;
        while (right < s.length()) {
            char c = s.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 (valid == need.size()) {
                if (right - left < len) {
                    start = left;
                    len = right - left;
                }

                char c1 = s.charAt(left);
                left++;
                if (need.containsKey(c1)) {
                    if (window.get(c1).equals(need.get(c1))) {
                        valid--;
                    }
                     window.put(c1, window.getOrDefault(c1, 0) - 1);
                }

            }
        }

        return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
    }

}