数据结构与算法自用笔记（数组——长度最小的子数组、水果成篮、最小覆盖子串）-优快云博客

本文链接：https://blog.youkuaiyun.com/xxyxxxqqq/article/details/144071514

长度最小的子数组力扣原题：

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

解答：

最先开始采用的解法：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
        int k=nums.length-1;
        int sum=0;
        int flag=0;
        while(k>=0){
            sum=sum+nums[k];
            if(sum>=target){
                flag=1;
                break;
            }else{
                k--;
            }
        }
        if(flag==1){
            return nums.length-k;
        }else{
            return 0;
        }
    }
}

后来发现测试不通过，原来是因为题目要求的是不能变换数组原本的位置，要在原来的位置上进行寻找最小的子数组。

滑动窗口解法：

滑动窗口：用一个for循环，让 i 指向起始位置，让 j 指向终止位置，随着for循环一直往后挪，当 i 和 j 形成一个能够满足题目要求的区间之后，将 i 这个起始位置往后挪，逐渐缩小区间，一旦进入while循环，总能找到一个满足题目要求的区间，它的大小就是result，等到缩小后的区间不再满足while循环的条件以后，跳出while循环，继续for循环，然后再次满足条件进入while循环，这个时候就可以把上一次记下来的result和 j - i +1 比较一下哪个小，哪个小就继续取哪个值，就这样一直到整个数组都被遍历一次，如果等到最后result的值还是初始化的值，就证明根本没有进入过while循环，也就是没有找到过适合的区间，这时候返回0.

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i=0,j,sum=0,result=Integer.MAX_VALUE;
        for(j=0;j<nums.length;j++){
            sum=sum+nums[j];
            while(sum>=target){
                result=Math.min(result,j-i+1);
                sum=sum-nums[i];
                i++;
            }
        }
        return result==Integer.MAX_VALUE? 0: result;//这个判断语句需要bool值，所以要result==Integer.MAX_VALUE
}
}

水果成篮力扣原题：

904. 水果成篮 - 力扣（LeetCode）

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

你只有两个篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从每棵树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的最大数目。

示例 1：

输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：

输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

解答：

题意解析：

你有一个大篮子，这个篮子可以装2种水果，沿着fruits数组顺序收集水果，如果遇到和篮子里的两种水果冲突的其他种类的水果，那么你需要放弃一种水果，就这样一路收集，一路放弃，最终的目的是要能找到最多的水果数。

滑动窗口解题：

设置一个left和right，right向后遍历所有的水果，每遇到一种水果就放到大篮子fruitsSort中，水果的数量逐渐累加，当篮子里的水果种类大于2的时候就要舍弃一些水果，这个时候用left向后遍历，把left经过的水果舍弃掉，若是水果的数量减少为0就把水果种类从篮子里除名。当篮子里的水果种类再次小于等于2的时候，就可以将篮子现有的水果数量全部累加起来（起始left和right圈起来的这个区间就是你摘的水果的数量），把这个数量记录为result，然后继续向后遍历，每次都把新得到的result和之前的result相比，取数量最大的那个，等到整个fruits数组遍历完成之后，就可以拿到可以采摘的最多水果数量了。

class Solution {
    public int totalFruit(int[] fruits) {
        int left=0,right,result=Integer.MIN_VALUE;
        int sum=0;
        HashMap<Integer,Integer> fruitsSort=new HashMap();
        for(right=0;right<fruits.length;right++){
            fruitsSort.put(fruits[right],fruitsSort.getOrDefault(fruits[right],0)+1);//如果存在fruitsSort[right]，则取出对应的value值+1，如果不存在，则得到0+1
            while(fruitsSort.size()>2){
                fruitsSort.put(fruits[left],fruitsSort.get(fruits[left])-1);
                if(fruitsSort.get(fruits[left])==0){
                    fruitsSort.remove(fruits[left]);
                }
                left++;
            }
            result=Math.max(result,right-left+1);
        }
        return result;
    }
}

最小覆盖子串力扣原题：

76. 最小覆盖子串 - 力扣（LeetCode）

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

注意：

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

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

解答：

自己写的时间复杂度为O(n^2)的滑动窗口解法：

class Solution {
    public String minWindow(String s, String t) {
        int left=0,right,flag;//滑动窗口
        String result=s+"z";//设置一个比s要大的字符串，如果result的值没有变过，就证明没有符合t的字符串，返回""
        Map<Character,Integer> tCount=new HashMap<>();
        Map<Character,Integer> sCount=new HashMap<>();
        for(char c : t.toCharArray()){//记录t中字符的数量
            tCount.put(c,tCount.getOrDefault(c,0)+1);
        }
        for(right=0;right<s.length();right++){//right从s的索引0开始向后获取字符
            flag=0;//作为s是否包含t中所有字符的标记，0是包含，1是不包含
            char c=s.charAt(right);
            sCount.put(c,sCount.getOrDefault(c,0)+1);
            for(Character key : tCount.keySet()){
                if(sCount.containsKey(key)){//判断s是否包含t中的字符key
                    if(tCount.get(key)>sCount.get(key)){//当前窗口无法包含所有的t
                        flag=1;
                    }
                }else{//若不包含，则代表当前的窗口无法包含所有的t
                    flag=1;
                }
            }
            while(flag==0){//当前窗口可以包含所有t字符
                result=result.length()>=s.substring(left,right+1).length()?s.substring(left,right+1):result;//更新最小的字符串结果
                char ch=s.charAt(left);//left向后挪，删去当前所在的字符
                sCount.put(ch,sCount.getOrDefault(ch,1)-1);
                left++;
                for(Character key : tCount.keySet()){//如果left向后挪动后的窗口无法满足t，则将flag=1，若满足t，则继续while循环，也就是left往后挪
                if(sCount.containsKey(key)){
                    if(tCount.get(key)>sCount.get(key)){
                        flag=1;
                    }
                }else{
                    flag=1;
                }
            }
            }
        }
        if(result.equals(s+"z")){
            return "";
        }else return result;
    }
}

官方解法

class Solution {
    Map<Character, Integer> ori = new HashMap<Character, Integer>();
    Map<Character, Integer> cnt = new HashMap<Character, Integer>();

    public String minWindow(String s, String t) {
        int tLen = t.length();
        for (int i = 0; i < tLen; i++) {
            char c = t.charAt(i);
            ori.put(c, ori.getOrDefault(c, 0) + 1);
        }
        int l = 0, r = -1;
        int len = Integer.MAX_VALUE, ansL = -1, ansR = -1;
        int sLen = s.length();
        while (r < sLen) {
            ++r;
            if (r < sLen && ori.containsKey(s.charAt(r))) {
                cnt.put(s.charAt(r), cnt.getOrDefault(s.charAt(r), 0) + 1);
            }
            while (check() && l <= r) {
                if (r - l + 1 < len) {
                    len = r - l + 1;
                    ansL = l;
                    ansR = l + len;
                }
                if (ori.containsKey(s.charAt(l))) {
                    cnt.put(s.charAt(l), cnt.getOrDefault(s.charAt(l), 0) - 1);
                }
                ++l;
            }
        }
        return ansL == -1 ? "" : s.substring(ansL, ansR);
    }

    public boolean check() {
        Iterator iter = ori.entrySet().iterator(); 
        while (iter.hasNext()) { 
            Map.Entry entry = (Map.Entry) iter.next(); 
            Character key = (Character) entry.getKey(); 
            Integer val = (Integer) entry.getValue(); 
            if (cnt.getOrDefault(key, 0) < val) {
                return false;
            }
        } 
        return true;
    }
}