76.最小覆盖子串_567.字符串排列_438.找所有字母异位词_3.最长无重复子串_209. 长度最小的子数组

在这里插入图片描述

总结

  • 这四道题要求的都是连着的子串,所以可以用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;
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值