【LeetCode】滑动窗口

滑动窗口

覆盖子串问题

https://leetcode-cn.com/problems/minimum-window-substring/solution/tong-su-qie-xiang-xi-de-miao-shu-hua-dong-chuang-k/

⭐76. 最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
• 如果 s 中存在这样的子串，我们保证它是唯一的答案。

class Solution {
    public String minWindow(String s, String t) {
        // 用cnt表示t中还有多少个字符没有匹配好，need表示具体的剩余匹配个数
        int[] need = new int[128];
        int left = 0, right = 0, cnt = t.length();
        int min_size = Integer.MAX_VALUE;
        String res = "";
        for (char c : t.toCharArray()) {
            need[c]++;
        }
        while (right < s.length()) {
            char r_char = s.charAt(right);
            if (need[r_char] > 0) {
                cnt--;
            }
            need[r_char]--;
            if (cnt == 0) {
                // 缩减到当前最小窗口
                while (need[s.charAt(left)] < 0) {
                    need[s.charAt(left)]++;
                    left++;
                }
                // 判断当前的最小窗口
                if ((right - left + 1) < min_size) {
                    min_size = right - left + 1;
                    res = s.substring(left, right + 1);
                }
                // 缩减窗口
                char l_char = s.charAt(left);
                need[l_char]++;
                left++;
                cnt++;
            }
            right++;
        }
        return res;
    }
}

567. 字符串的排列

难度中等622

给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。

换句话说，s1 的排列之一是 s2 的 子串 。

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        if (s1.length() > s2.length()) return false;
        int[] need = new int[128];
        int cnt = s1.length();
        for (int i = 0; i < s1.length(); i++) {
            need[s1.charAt(i)]++;
        }

        int l = 0, r = 0;
        while (r < s2.length()) {
            if (need[s2.charAt(r)] > 0) {
                cnt--;
            }
            need[s2.charAt(r)]--;
            if (cnt == 0) {
                while (need[s2.charAt(l)] < 0) {
                    need[s2.charAt(l)]++;
                    l++;
                }
                if (r - l + 1 == s1.length()) {
                    return true;
                }
                need[s2.charAt(l)]++;
                cnt++;
                l++;
            }
            r++;
        }
        return false;
    }
}

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

难度中等828

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();
        if (s.length() < p.length()) return res;
        int[] need = new int[128];
        int cnt = p.length();
        for (int i = 0; i < p.length(); i++) {
            need[p.charAt(i)]++;
        }

        int l = 0, r = 0;
        while (r < s.length()) {
            if (need[s.charAt(r)] > 0) {
                cnt--;
            }
            need[s.charAt(r)]--;
            if (cnt == 0) {
                while (need[s.charAt(l)] < 0) {
                    need[s.charAt(l)]++;
                    l++;
                }
                if (r - l + 1 == p.length()) {
                    res.add(l);
                }
                need[s.charAt(l)]++;
                cnt++;
                l++;
            }
            r++;
        }
        return res;
    }
}

滑动窗口

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int l = 0, r = 0, sum = 0;
        int minSize = Integer.MAX_VALUE;
        while (r < nums.length) {
            sum += nums[r++];
            while (sum >= target) {
                minSize = Math.min(minSize, r - 1 - l + 1);
                sum -= nums[l++];
            }
        }
        return minSize == Integer.MAX_VALUE ? 0 : minSize;
    }
}

30. 串联所有单词的子串

给定一个字符串 s 和一些 长度相同 的单词 words **。**找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符 ，但不需要考虑 words 中单词串联的顺序。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        // 对于s的一个子区间，这个子区间切成字符串后正好对应words中的元素
        List<Integer> res = new ArrayList<>();
        int n = words.length, len = words[0].length();
        int total = n * len;
        Map<String, Integer> wordMap = new HashMap<>();
        for (String word : words) {
            wordMap.put(word, wordMap.getOrDefault(word, 0) + 1);
        }
        for (int i = 0; i <= s.length() - total; i++) {
            Map<String, Integer> map = new HashMap<>();
            String cur = s.substring(i, i + total);
            boolean flag = true;
            for (int j = 0; j <= n - 1; j++) {
                // [0, len] [len, 2len] .... [(n-1)len, nlen]
                String temp = cur.substring(j * len, (j + 1) * len);
                if (wordMap.containsKey(temp) && map.getOrDefault(temp, 0) < wordMap.get(temp)) {
                    map.put(temp, map.getOrDefault(temp, 0) + 1);
                } else {
                    flag = false;
                    break;
                }
            }
            if (flag) res.add(i);
        }
        return res;
    }
}