labuladong的算法小抄利用滑动窗口解题

Fxxkke

于 2023-04-25 21:57:38 发布

阅读量158

点赞数

分类专栏： labuladong 文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/Fxxkke/article/details/130375031

版权

labuladong 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

76. 最小覆盖子串

class Solution {
    public String minWindow(String s, String t) {
        //最小覆盖子串解题：思路使用滑动窗口解决字串问题
        //注意java中的字符串操作比较复杂，以及equal()方法
        //首先创建两个map用来存储父串和子串元素出现的个数
        Map<Character,Integer> window = new HashMap<>();
        Map<Character,Integer> need = new HashMap<>();
        //统计子串中个元素的个数，给need初始化,注意将string转化为array
        for(char c : t.toCharArray()){
            need.put(c,need.getOrDefault(c,0)+1);
        }
        int left = 0;
        int right = 0 ;
        int valid = 0 ;//统计满足要求的元素的个数
        //记录最小覆盖子串的初始索引和长度
        int start = 0;
        int 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;
                }
                //d是将要移除滑动窗口的函数
                char d = s.charAt(left);
                left++;
                //对窗口内的海曙进行一系列处理
                if(need.containsKey(d)){
                    if(window.get(d).equals(need.get(d))){
                        valid--;

                    }
                     window.put(d, window.get(d) - 1);
                }
            }
        }
        return len == Integer.MAX_VALUE ?
        "" : s.substring(start, start + len);
    }
}

567. 字符串的排列

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        //本题使用滑动窗口解题,使用框架
        //相当给你一个 S 和一个 T，请问你 S 中是否存在一个子串，包含 T 中所有字符且不包含其他字符？
        HashMap<Character,Integer> need = new HashMap<>();
        HashMap<Character,Integer> window = new HashMap<>();
        //将s1中的值-出现的次数映射到need map中
        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 ,valid = 0;
        //使用滑动窗口
        while(right < s2.length()){
            char c = s2.charAt(right);
            //增大窗口
            right ++;
            if (need.containsKey(c)){
                //对窗口内的数进行处理
                window.put(c,window.getOrDefault(c,0)+1);
                //让窗口中的值+1
                if(window.get(c).equals(need.get(c))){
                    valid++;
                }
            }
            //收缩窗口
            while(right - left >= s1.length()){
                //注意此处是比较的是need窗口中的大小
                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.getOrDefault(d,0)-1);
                }
            }
        }
        return false;
    }
}

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

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        //异位词相当于排列，可以参考567.字符串的排列
        //使用滑动窗口
        Map<Character,Integer> need = new HashMap<>();
        Map<Character,Integer> window = new HashMap<>();
        //将p字符串映射到need map中
        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, valid = 0;
        //new一个数组用来存放结果
        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(window.get(c).equals(need.get(c))){
                    valid++;
                }
            }
            
            
            while (right - left >= p.length()){
                //收缩
                if(valid == need.size()){
                    res.add(left);//存放起始地址
                }
                char d = s.charAt(left);
                left++;
                if(need.containsKey(d)){
                    if (window.get(d).equals(need.get(d))){
                        valid--;
                    }
                    window.put(d,window.getOrDefault(d,0)-1);
                }
            }
        }
        return res;
    }
}

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

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //本题是滑动窗口解题，但是跟传统的有点区别
        Map<Character,Integer> window = new HashMap<>();
        int left = 0, right = 0,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.getOrDefault(d,0)-1);
            }
            res = Math.max(res,right - left);
        }
        return res;
    }
}