总结
- 这四道题要求的都是连着的子串，所以可以用left，right滑动窗找到满足条件的；
- right向右找，满足条件后，停止，此时，在满足条件的情况下，left++，不满足条件后，跳出循环，right++，由此遍历。
- hashmap结构，记录字符，和字符出现的次数；
- 细节：right++时，当window.get(in) == needs.get(in) valid++;
- left++, 当window.get(out) < needs.get(out) valid–;
76. 最小覆盖子串
给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入：S = “ADOBECODEBANC”, T = “ABC”
输出：“BANC”
- 答案
class Solution {
public String minWindow(String s, String t) {
int left,right,count,minLen= Integer.MAX_VALUE;
int start=0,end=0;
//needs存储t的<字符,出现次数>,windows存储<s中与t中字符相同的字符,出现次数>
HashMap<Character,Integer> needs = new HashMap<>();
HashMap<Character,Integer> windows = new HashMap<>();
//初始化needs
for(int i=0;i<t.length();i++){
//needs.getOrDefault(t.charAt(i),0)+1 含义是：needs如果包含t.charAt(i)，
//则取出值+1;不包含取0+1
needs.put(t.charAt(i),needs.getOrDefault(t.charAt(i),0)+1);
}
left=right=count=0;
while(right <s.length()){
//获取字符
char temp=s.charAt(right);
//如果是t中字符，在windows里添加，累计出现次数
if(needs.containsKey(temp)){
windows.put(temp,windows.getOrDefault(temp,0)+1);
//注意：Integer不能用==比较，要用compareTo
if(windows.get(temp).compareTo(needs.get(temp))==0 ){
//字符temp出现次数符合要求，count代表符合要求的字符个数
count++;
}
}
//优化到不满足情况，right继续前进找可行解
right++;
//符合要求的字符个数正好是t中所有字符，获得一个可行解
while(count==needs.size()){
//更新结果
if(right-left<minLen){
start=left;
end=right;
minLen=end-left;
}
//开始进行优化，即缩小区间，删除s[left],
char c=s.charAt(left);
//当前删除的字符包含于t,更新Windows中对应出现的次数，如果更新后的次数<t中出现的次数，符合要求的字符数减1，下次判断count==needs.size()时不满足情况，
if(needs.containsKey(c)){
windows.put(c,windows.getOrDefault(c,1)-1);
if(windows.get(c)<needs.get(c)){
count--;
}
}
left++;
}
}
//返回覆盖的最小串
return minLen==Integer.MAX_VALUE ? "":s.substring(start,end);
}
}
- 自己想法
class Solution {
public String minWindow(String s, String t) {
// hashmap needs 记录t的字符和出现次数
// hashmap window 记录窗口的字符和出现字符
// 窗口，往右走，知道包含全部的t
// 然后left左边往右移，如果删除的不是t中的字符，则继续删
// 如果是的话，right继续向右走
// right走到头，结束
if(s == null || s.length() == 0
|| t == null || t.length() == 0) return "";
char[] charsS = s.toCharArray();
char[] charsT = t.toCharArray();
int sLen = charsS.length, tLen = charsT.length;
HashMap<Character, Integer> needs = new HashMap<>();
HashMap<Character, Integer> window = new HashMap<>();
int right = 0, left = 0;
int count = 0;
int min = Integer.MAX_VALUE;
int start = 0, end = 0;
for(int i = 0; i < tLen; i++) {
needs.put(charsT[i], needs.getOrDefault(charsT[i], 0) + 1);
}
while(right < sLen) {
// 向右走，每走一步判断是否是t中的，是，就加1，如果等于t中的数字，count+1, count如果等于needs的size，left就要往右移了
// left往右移，看是否是t中的字符，如果是，则次数减1，count-1, right要向右移了，否则，继续left右移
while(right < sLen && count < needs.size()) {
char c = charsS[right];
if(needs.containsKey(c)) {
window.put(c, window.getOrDefault(c, 0) + 1);
if(window.get(c).compareTo(needs.get(c)) == 0) {
count++;
}
}
right++;
}
while(left< sLen && count == needs.size()) {
if((right - left) < min) {
min = right - left;
start = left;
end = right;
}
char out = charsS[left];
if(needs.containsKey(out)) {
window.put(out, window.getOrDefault(out, 1) - 1);
if(window.get(out) < needs.get(out)) {
count--;
}
}
// count 什么时候-1，不能每次都减，肯定不够减，错了，当你减1时，就立刻会right++
// 不会让你继续减
// 当getc == 0时减，也不行，因为应该是只有有一个不相等，就应该向右移
left++;
}
}
return min == Integer.MAX_VALUE ? "" : s.substring(start, end);
}
}
-
出错点：
- left++,right++ 乱加，想清楚，while里面的right++,left++一般都是刚好满足条件的left ,right, 然后为了以下一次又加了++，然后再判断的条件，不满足while里的条件，退出，此时left，right已经多加了一个。
- eg: 我的错误：第二个left的while下面，我加了一个right++，想着是减掉了一个左边不满足后，应该right向后移，但上一个right的while结束时，right就已经指向了后一个了。
- eg: 我的错误：第一个right的while结束后，我加了一个left++ ， 想着刚好count == map.size(), 应该left向右移，删掉一个，但应该是从left开始删，应为s.charAt(left)有可能不包含在t中，也有可能包含在t中，而不是从left++开始删。
-
当字符串很大时，计数int无法满足,应该window.get©.compareTo(needs.get©) == 0，Integer范围更大。
-
细节：
if(window.get(out) < needs.get(out)) {
count--;
}
这里是 < , 就减，因为有可能其中的字符数大于t中字符数，不能说 走到s.charAt(left) 包含在t中，就count–, 有可能去掉了这个，count依然满足，因为get(s.charAt(left))有多的。
567. 字符串的排列
给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。
换句话说，第一个字符串的排列之一是第二个字符串的子串。
示例1:
输入: s1 = “ab” s2 = “eidbaooo”
输出: True
解释: s2 包含 s1 的排列之一 (“ba”).
示例2:
输入: s1= “ab” s2 = “eidboaoo”
输出: False
- right向右，直到left,right 包含了所有t中出现的字符；
- 在while(valid == need.size())中不断试探，left++, 为什么是valid == need.size()，可以好好思考下，因为后面判断一旦有valid < need.size()时，即只要有效字符少了一个，right就会重新向右移，所以这里可以判断。当 right - left == t.length()时，说明刚好满足，没有多余的字母。这里很有意思，也是和76,3两道题的中间地带。
class Solution {
public boolean checkInclusion(String t, String s) {
// 滑动窗
// 和最长无重复子串不同，这里顺序不同也行， start,end
// 和覆盖最小子串不同，这里需要连续. window = hashmap
HashMap<Character, Integer> need = new HashMap<>();
HashMap<Character, Integer> window = new HashMap<>();
char[] charsT = t.toCharArray();
char[] charsS = s.toCharArray();
int tLen = charsT.length;
int sLen = charsS.length;
for(int i = 0; i < t.length(); i++) {
char c = charsT[i];
need.put(c, need.getOrDefault(c, 0) + 1);
}
int left = 0, right = 0, valid = 0;
while (right < sLen) {
char in = charsS[right];
if(need.containsKey(in)) {
window.put(in,
window.getOrDefault(in, 0) + 1);
if(window.get(in).compareTo(need.get(in)) == 0) {
valid++;
}
}
right++;
while (valid == need.size()) {
if((right - left) == tLen) {
return true;
}
char out = charsS[left];
if(need.containsKey(out)) {
window.put(out,
window.getOrDefault(out, 1) - 1);
if(window.get(out) < need.get(out)) {
valid--;
}
}
left++;
}
}
return false;
}
}
438.找所有字母异位词
给定一个字符串 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” 的字母异位词。
class Solution {
public List<Integer> findAnagrams(String s, String p) {
// 和 一模一样，只不过一个输出true，一个输出left
// right一直向右，直到包含所有
// 在满足条件下，left++
// 如果window == needs.size() 则将left添加到答案中
List<Integer> ans = new ArrayList<>();
if(s == null || p == null) return ans;
if(s.length() == 0 || p.length() == 0) return ans;
char[] charsS = s.toCharArray(), charsP = p.toCharArray();
int lenS = charsS.length, lenP = charsP.length;
HashMap<Character, Integer> window = new HashMap<>();
HashMap<Character, Integer> needs = new HashMap<>();
for(int i = 0; i < lenP; i++) {
char c = charsP[i];
needs.put(c, needs.getOrDefault(c, 0) + 1);
}
int left = 0, right = 0, valid = 0;
while(right < lenS) {
while(right < lenS && valid < needs.size()) {
char in = charsS[right];
if(needs.containsKey(in)) {
window.put(in, window.getOrDefault(in, 0) + 1);
if(window.get(in).compareTo(needs.get(in)) == 0) {
valid++;
}
}
right++;
}
while(left < lenS && valid == needs.size()) {
if((right - left) == lenP) {
ans.add(left);
}
char out = charsS[left];
if(needs.containsKey(out)) {
window.put(out, window.getOrDefault(out, 1) - 1);
if(window.get(out) < needs.get(out)) {
valid--;
}
}
left++;
}
}
return ans;
}
}
209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
示例：
输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
进阶：
如果你已经完成了 O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。
class Solution {
public int minSubArrayLen(int s, int[] nums) {
// right向右，直到满足条件，
// 满足条件，在满足条件的情况下，left++,
// 比较最小
if(nums == null || nums.length == 0) return 0;
int left = 0, right = 0, minLen = Integer.MAX_VALUE, sum = 0;
int len = nums.length;
while(right < len) {
while(right < len && sum < s) {
sum += nums[right];
right++;
}
while(left < len && sum >= s) {
if((right - left) < minLen) {
minLen = (right - left);
}
sum -= nums[left];
left++;
}
}
return minLen == Integer.MAX_VALUE ? 0 : minLen;
}
}
扫一扫
107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
