算法随手记Day9--滑动窗口

1.长度最小的子数组

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

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

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2

思路

暴力解法

1.要求查找长度最小的数组，那么就可以按照数组长度resultLength在1~n这样遍历

2.然后再根据resultLength，从头到尾的获取长度为resultLength的所有数组

3.数组求和和target值对比，如果大于等于直接返回，最终没有找到结果就返回0

代码实现

    public int minSubArrayLen(int target, int[] nums) {
        int resultLength = 1;
        int length = nums.length;
        //首先是根据是长度递增的去寻找
        while (resultLength <= nums.length) {
            //从下标0开始获取到长度为resultLength的数组
            for (int i = 0; i < length - resultLength; i++) {
                int sum = 0;
                //求和，如果大于等于target就直接返回结果长度
                for (int j = i; j < i + resultLength; j++) {
                    sum += nums[j];
                    if (sum >= target) {
                        return resultLength;
                    }
                }

            }
            resultLength++; 
        }
        return 0;
    }

复杂度过高，不符合要求

滑动窗口思想

1.首先从头到尾遍历出一个和>target的数组

2.移动这个数组的起始位置，判断是否依然符合>target，如果符合，判断长度然后更新最小长度，不符合继续移动数组的终点位置

3.按照这样的思路找出最小的长度返回

代码实现

	public int minSubArrayLen(int target, int[] nums) {
        int resultLength = nums.length + 1;
        int right = 0;
        int sum = 0;
        //首先移动终点位置
        while (right < nums.length) {
            int left = 0;
            sum += nums[right];
            int tempSum = sum;
            while (tempSum >= target) {
                tempSum -= nums[left];
                resultLength = Math.min(resultLength, right - left + 1);
                left++;
            }
            right++;
        }
        return resultLength <= nums.length ? resultLength: 0;
    }

问题

当起始指针找到了和大于target的最小数组后，后面移动右指针不需要再从头再来遍历，直接继续起始指针即可，因为数组是正整数

所以最终的代码如下

    public int minSubArrayLen2(int target, int[] nums) {
        int resultLength = nums.length + 1;
        int right = 0;
        int sum = 0;
        int left = 0;
        //首先移动终点位置
        while (right < nums.length) {
            sum += nums[right];
            while (sum >= target) {
                sum -= nums[left];
                resultLength = Math.min(resultLength, right - left + 1);
                left++;
            }
            right++;
        }
        return resultLength <= nums.length ? resultLength: 0;
    }

滑动窗口的思想是什么？

先是移动终点位置，找到符合条件的数组，然后再移动起始位置，一点点的寻找到最小的结果，寻找到结果后再移动终点位置，一点点的寻找到最终结果

2.无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。

示例 1:

输入: s = "pwwkew"
输出: 3 
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。。

	public int lengthOfLongestSubstring(String s) {
        // 单个字符作为key，字符在字符串中的下标作为value
        Map<Character, Integer> map = new HashMap<>();
        // 最大值
        int maxLen = 0;
        // 左边界
        int left = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            /**
             * 要理解下面的代码首先要想明白获得最长字串的逻辑
             * 这里一共存在两个变量：
             *  - left：表示字串最左边字符的索引位置
             *  - i：遍历的每个字符索引位置，我们全靠这个字符来完成这道题，i这个变量存在三种情况需要考虑
             *      1） s.charAt(i)在[left, i)之间不存在重复字符
             *          - 就把s.charAt(i)放到map中，最长长度同时也加一
             *      2） s.charAt(i)在[left, i)之间存在重复字符
             *          - 获得[left, i)范围内重复字符的下标h，让left = h + 1，此时新的字串开始匹配，新的长度变成了i - left + 1 = 1
             *          - 更新map中重复字符的索引位置为i
             *      3） s.charAt(i)在[0, left)之间存在重复字符
             *          - 我们在发现重复字符后都要更新该字符在map中的索引位置，就是为了避免之前的重复元素对当前判断造成影响
             *          - 但是譬如acbba这样一个字符：当遍历到第二个b时，可知h = map.get('b')，所以h=2，那么newLeft=h+1=3;
             *              之后遍历到字符a，h = map.get('a')，发现此时h=0，newLeft=h+1=1；这种情况明显不合理，所以要求left=Math.max(left, newLeft)
             *          - 更新map中重复字符的索引位置为i，最长长度同时也加一
             *
             */
            if (map.containsKey(c)) {
                left = Math.max(left, map.get(c) + 1);
            }
            map.put(c, i);
            maxLen = Math.max(maxLen, i - left + 1);
        }
        return maxLen;
    }