刷Leecode第6天，滑动窗口之无重复字符的最长字串和字符串 的排列

滑动窗口算法的使用需要搭配哈希表的键-值存放属性相结合，本身存在难度。来看看第一题：

无重复字符的最长字串

思路： int  ans 为当前无重复字符串最大长度。新建哈希表，key存放字符串的单个字符char，value存放当前char所在字符串中的位置，一开始，left和right都在0处，即字符串开始处，right右移，将扫描到的字符存储在哈希表中，同时做判断，如果是新字符则不断移动，ans更新。如果里面有已经有重复的key了，则left移动至上个重复Key对应value后一位处，ans更新。不断重复直到right走到头 

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //ans为目前最长的长度
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>();
        for (int end = 0, start = 0; end < n; end++) {
            //右移取到当前字符
            char alpha = s.charAt(end);
            //如果map里有当前字符了，左指针（左窗口）移到到上一个重复字符的后一位
            if (map.containsKey(alpha)) {
                start = Math.max(map.get(alpha), start);
            }
            //ans长度更新，当前长度值和历史最大长度值时时比较
            ans = Math.max(ans, end - start + 1);
            //存放
            map.put(s.charAt(end), end + 1);
        }
        return ans;
    }
}

第二题字符串的排列

思路 ：首先，需要明白的是！排列不会改变字符串中每个字符的个数，所以只有当两个字符串每个字符的个数均相等时，一个字符串才是另一个字符串的排列。

根据这一性质，记 s1 的长度为 n，我们可以遍历 s2 中的每个长度为 n 的子串，判断子串和 s1 中每个字符的个数是否相等，若相等则说明该子串是 s1 的一个排列。

我们在字符串 s2 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引左闭右开区间[left, right)称为一个「窗口」。

1. 我们先不断地增加 right 指针扩大窗口 [left, right)，直到窗口中的字符数量等于 s1 中不同字符的个数, 则收缩窗口

2. 此时，我们停止增加 right，转而不断增加 left 指针缩小窗口 [left, right)，直到窗口中的字符数量 < s1 中不同字符的个数或者窗口中已经拥有 s1 的排列。

很显然，这个左窗口收缩操作每次只可能做一次，因为 left 一左移窗口中字符的数量就小于 s1 的长度了

重复第 2 和第 3 步，直到 right 到达字符串 s2 的尽头。

简单来说，第 1 步相当于在寻找一个可能的解，第 2 步具体的来判断这个解是不是真的可行。

至于如何判断是否窗口中的字符是 s1 的排列呢？

这就需要我们引入一个额外的变量 vaild，用来表示窗口中满足条件的字符个数。

首先用一个 map（记为 need）记录 s1 中的字符及其数量，当窗口 window 中的某个字符数量和 need 中该字符的数量相等的时候，我们就认为这个字符是 OK 的，即令 vaild + 1。
当 vaild = s1.length 的时候，就说明窗口中已经完全包含了 s1 的排列，返回 True 即可。

详解看代码

class Solution {
    
    public boolean checkInclusion(String s1, String s2) {
        if (s2 == null || s2.length() == 0) {
            return false;
        }

        // 记录 s1 中的字符及其对应的个数
        HashMap<Character, Integer> need = new HashMap<>();
        for(int i = 0; i < s1.length(); i ++){
            char c = s1.charAt(i);
            need.put(c, need.getOrDefault(c, 0) + 1);
        }

        // 滑动窗口
        HashMap<Character, Integer> window = new HashMap<>();
        int left = 0;
        int right = 0;

        // 表示窗口中满足 need 条件的字符个数
        int vaild = 0;

        while (right < s2.length()) {
            char newChar = s2.charAt(right);
            // 扩大窗口
            right ++;
            // 如果该字符存在于字符串 s1 中，则更新窗口数据以及 vaild (不存在的话没有更新的必要)
            if (need.containsKey(newChar)) {
                window.put(newChar, window.getOrDefault(newChar, 0) + 1);
                // 若窗口中的该字符满足 need 条件，则 vaild ++
                if (window.get(newChar).equals(need.get(newChar))) {
                    vaild ++;
                }
            }


            // 窗口中的字符数量等于 need 的大小(s1 中不同字符的个数), 则收缩窗口
            while (right - left == s1.length()) {
                if (vaild == need.size()) {
                    return true;
                }

                // 收缩窗口
                char removeChar = s2.charAt(left);
                left ++;

                // 如果被移除掉的字符存在于字符串 s1 中，则更新窗口数据以及 vaild (不存在的话没有更新的必要)
                if (need.containsKey(removeChar)) {
                    if (window.get(removeChar).equals(need.get(removeChar))) {
                        vaild --;
                    }
                    window.put(removeChar, window.get(removeChar) - 1);
                }
            }
        }

        return false;
    }
}