高频2. 无重复字符的最长子串 及其变形题的各种解法 Java codetop

题目描述

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

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

示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

各种解法

滑动窗口

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 滑动窗口，左右指针，用hashset验证是否重复
        int left =0, right = 0;
        int res = 0;
        HashSet<Character> set = new HashSet<>();
        while(right<s.length()){
            char rch = s.charAt(right);
            right++;
            while(set.add(rch) == false){ // 添加不成功，说明集合中已有了
                char lch = s.charAt(left);
                set.remove(lch); // 有重复，那么right不动，动left
                left++;
            }
            res = Math.max(res, right-left);
        }
        return res;
    }
}

解题思路：

• 滑动窗口的方法： left和right一开始都在最左；
• 首先right向后移动，直到遇到不满足题目要求的情况，也就是遇到了重复的字母，集合添加操作不成功；
• 之后left向后移动，直到去掉先前重复的字母，right的添加操作才能成功，才能计算最大的无重复字符长度。
• 用hashset来确定当前left和right之间的子串中是否有重复字符。
• 时间复杂度：O(n)

滑动窗口解题框架

/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;

    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移入窗口的字符
        char c = s[right];
        // 右移窗口
        right++;
        // 进行窗口内数据的一系列更新
        ...

        /*** debug 输出的位置 ***/
        printf("window: [%d, %d)\n", left, right);
        /********************/

        // 判断左侧窗口是否要收缩
        while (window needs shrink) {
            // d 是将移出窗口的字符
            char d = s[left];
            // 左移窗口
            left++;
            // 进行窗口内数据的一系列更新
            ...
        }
    }
}

变形题及其解法

1. 允许重复一次的最长子串

题目描述

在上面一题的基础上，允许每个字符重复一次，求最长的子串

解法

滑动窗口

public static int longestSubstring(String s){
        // 滑动窗口，现在变成可以重复1次
        int left = 0, right = 0;
        int res = 0;
        Map<Character, Integer> map = new HashMap<>();
        while (right<s.length()){
            char rch = s.charAt(right);
            right++;
            map.put(rch, map.getOrDefault(rch, 0)+1);
            while(map.get(rch) > 2){
                // 此时字符的重复次数已经到3个了，不满足条件了
                char lch = s.charAt(left);
                map.put(lch, map.get(lch)-1);
                left++;
            }
            res = Math.max(res, right-left);
        }
        return res;
    }

解题思路：

• 之前的题目要求，一个都不能重复，可以简单用set，利用他的不重复的天然属性。现在可以重复1次了。换句话说就是同一个字符不能出现3次及以上。所以这里要用Map来统计。
• 同样right指针一直向右移动，直到不满足条件，记录最大长度。
• 此后，left指针开始向右移动，直到又满足条件了。
• 按照这样的滑动窗口的方式，一直往后，始终保持窗口中的子串是满足要求的，不断更新最大长度。

2. 至多包含k个不同字符的最长子串

题目描述

至多包含k个不同字符的最长子串
定一个字符串 s ，找出 至多 包含 k 个不同字符的最长子串 T。

解法

滑动窗口

public static int longestSubstring(String s, int k){
        // 滑动窗口，左指针移动的条件是超过k个字符
        int left = 0, right = 0;
        int res = 0;
        Map<Character, Integer> map = new HashMap<>();
        while (right < s.length()){
            char rch = s.charAt(right);
            right++;
            map.put(rch, map.getOrDefault(rch, 0)+1);
            while(map.size() > k){ // 字符数量超过k个，左边开始移动
                char lch = s.charAt(left);
                map.put(lch, map.get(lch)-1);
                if (map.get(lch) == 0){ // 删完了，去除
                    map.remove(lch);
                }
                left++;
            }
            res = Math.max(res, right-left);
        }
        return res;
    }

解题思路：

• 这里的left指针移动的条件是：子串中的字符的种类大于k。
• 总是要保证子串中字符的种类最多k个。

3. 至少有k个重复字符的最长子串

题目描述

至少有k个重复字符的最长子串
现在要求这个最长子串中每个字符都要出现k次及以上

解法

滑动窗口

public static int longestSubstring(String s, int k){
        int res = 0;
        int n = s.length();
        int[] cnt = new int[26];
        for (int p = 1; p <= 26; p++) {
            Arrays.fill(cnt, 0);
            // total为在left和right之间所有的字符种类数量
            // sum为满足出现次数不少于k的字符数量
            for (int right = 0, left=0, total=0, sum=0; right < n; right++) {
                int rch = s.charAt(right)-'a';
                cnt[rch]++;
                if (cnt[rch] == 1) total++;// 字符种类+1
                if (cnt[rch] == k) sum++; // 满足条件字符+1
                // 区间字符种类超出限定数量p，需要删掉一些字符，左指针开始动
                while(total>p){
                    int lch = s.charAt(left)-'a';
                    cnt[lch]--;
                    if (cnt[lch] == 0) total--; // 减没了
                    if (cnt[lch] == k-1) sum--; // 满足条件的少一个
                }
                // 所有字符都满足要求，更新答案
                if (total == sum) res = Math.max(res, right-left+1);
            }
        }
        return res;
    }

解题思路：

• 记录多少字符符合条件（出现次数不少于k），区间所有字符都满足时，更新条件
• 给每轮的滑动窗口加一个条件，也就是滑动窗口中的字符种类是 p 个，从而把他变成一个确定性的问题。只要这p个都满足条件即可。
• 然后要把这个条件的所有情况，从1到26个字符遍历一遍，拿到最长的，即可。

分治

class Solution {
    public int longestSubstring(String s, int k) {
        if (s.length() < k) return 0;
        HashMap<Character, Integer> counter = new HashMap();
        for (int i = 0; i < s.length(); i++) {
            counter.put(s.charAt(i), counter.getOrDefault(s.charAt(i), 0) + 1);
        }
        for (char c : counter.keySet()) {
            if (counter.get(c) < k) {
                int res = 0;
                for (String t : s.split(String.valueOf(c))) {
                    res = Math.max(res, longestSubstring(t, k));
                }
                return res;
            }
        }
        return s.length();
    }
}

解题思路：

• 首先对字符串中的所有字符的数量进行统计，得到统计的结果。
• 如果其中某个字符的数量少于k个，那么任何包含该字符的子串都不可能满足要求。
• 所以以这个字符为分界，处理分割后的子串是否满足要求，递归检查。