【LeetCode刷题记录】 热题 100 —— 滑动窗口

相关博客

• 【LeetCode刷题记录】 热题 100 —— 哈希
• 【LeetCode刷题记录】 热题 100 —— 双指针

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

题目链接

这一题的解法是使用滑动窗口，滑动窗口顾名思义就是有一个移动的窗口区域，那么在区域里的一般来说就是需要的结果。

所以我们需要维护一个子串，它就作为窗口。遍历题目的入参字符串，如果当前字符不在维护的子串中，那么就拼接上去；如果它在子串中已经存在，那么就判断当前无重复子串的长度和维护的最长长度，并且删掉子串中这个字符以及它之前的字符，并且拼接上新的字符。思路参考下面的GIF图以及解题代码

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 维护结果
        int result = 0;
        // 维护子串
        StringBuilder str = new StringBuilder();
        // 遍历目标字符串
        for (char c : s.toCharArray()) {
            int i = str.indexOf(String.valueOf(c));
            // 判断字符是否重复
            if (i != -1) {
                // 记录最长长度
                result = Math.max(result, str.length());
                // 移除重复字符以及之前的字符
                str.delete(0, i + 1);
            }
            // 拼接新字符
            str.append(c);
        }
        return Math.max(result, str.length());
    }
}

438. 找到字符串中所有字母异位词

题目链接

首先最容易想到的暴力解法，遍历目标字符串，判断每一段是不是异位词。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> result = new ArrayList<>();
        char[] pChar = p.toCharArray();
        Arrays.sort(pChar);
        // 获得排过序的p字符串
        String sortP = new String(pChar);
        int length = sortP.length();
        // 遍历s串
        for (int i = 0; i < s.length(); i++) {
            // 如果剩余的长度不够一个p，直接退出
            if (i + length > s.length()) {
                break;
            }
            // 在当前窗口中构造一个有顺序的字符串
            char[] tempChar = s.substring(i, i + length).toCharArray();
            Arrays.sort(tempChar);
            // 判断是否是p的异位词（判断排过序的两个字符串是否相同）
            if (sortP.equals(new String(tempChar))) {
                result.add(i);
            }
        }
        return result;
    }
}

可以看到这个解法虽然成功了，但是耗时太多了，可能是对子串进行排序比较费时，所以我们需要进行优化。回想之前也做过一个异位词的算法题，可以通过数组来判断异位词，所以用数组的解法来优化一下，就不需要对子串进行排序了。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> result = new ArrayList<>();
        int length = p.length();
        int[] pChar = new int[27];

        for (int i = 0; i < p.length(); i++) {
            pChar[p.charAt(i) - 'a']++;
        }

        for (int i = 0; i < s.length(); i++) {
            int[] sChar = new int[27];
            if (i + length > s.length()) {
                break;
            }
            for (int j = i; j < i + length; j++) {
                sChar[s.charAt(j) - 'a']++;
            }
            if (Arrays.equals(sChar, pChar)) {
                result.add(i);
            }
        }

        return result;
    }
}

优化之后确实快了很多，但是500ms还是有点慢的，毕竟只击败了不到20%，所以继续想办法优化。现在的解法中，每次都要重新构造一个子串的数组，有没有办法和上一题那样，通过滑动窗口来维护，每次删去不在窗口里的元素并且添加新进入窗口的元素，所以得到下面的解法。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> result = new ArrayList<>();
        int length = p.length();
        int[] pChar = new int[26];
        int[] sChar = new int[26];

        if (s.length() < p.length()) return result;

        for (int i = 0; i < p.length(); i++) {
            pChar[p.charAt(i) - 'a']++;
            sChar[s.charAt(i) - 'a']++;
        }

        if (Arrays.equals(sChar, pChar)) {
            result.add(0);
        }

        for (int i = 0; i < s.length() - length; i++) {
            
            sChar[s.charAt(i) - 'a']--;
            sChar[s.charAt(i + length) - 'a']++;

            if (Arrays.equals(sChar, pChar)) {
                result.add(i+1);
            }
        }

        return result;
    }
}

最后终于把时间降低到 10ms 之内了