【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;
}
}