3. Longest Substring Without Repeating Characters [Medium]

滑动窗口法

不要忘了考虑到字符串结尾的最后一个子串

本题自己用的map保存每个出现的字符和最后一次出现的位置，见第一个解答

也可以用set，只保存出现过的字符不保存出现的位置，见第二个解答

map更快：

用set则虽然能知道字符发生重复，却不知道重复字符的上一个位置，需要从当前子串的head开始遍历，也就是在题解的remove()的过程中找到这个位置，然后才能知道新head的位置、子串长度

而用map能直接获得前面重复位置的坐标，直接更新head和计算子串长度

用set比用map多了从结束子串的开头循环remove()到新子串开头的过程（“solution2的while”比“solution1的for”多几次循环，前者是“字符串长度 + 每个旧子串到新子串开头的长度差”，后者仅是“字符串长度”）

/**
 * 自己的代码，滑动窗口法
 * 用head保存每个子串的开头，map保存每个出现的字符和最后一次出现的位置，在遍历字符串的过程中更新map，每个子串结束的时候更新head
 * 遍历字符串，若当前字符在map中有对应key，则说明在前面部分出现过该字符，get出位置
 * 如果出现在head之前，则不用管，因为上一个字符不在我们当前考虑的子串内
 * 如果出现在head之后，则当前子串结束，更新head和最大长度
 * Runtime: 5 ms, faster than 80.61%
 * Memory Usage: 39.3 MB, less than 41.24%
 */
class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap<>();
        int head = 0, ans = 0;
        for (int i = 0; i < s.length(); i++) {
            char curr = s.charAt(i);
            if (map.containsKey(curr) && map.get(curr) >= head) {
                ans = Math.max(ans, i - head);
                head = map.get(curr) + 1;
            }
            map.put(curr, i); // 加入新值 or 更新旧值
        }
        return Math.max(ans, s.length() - head); // s.length() - head 是到字符串结尾的最后一个子串的长度
    }
}

/**
 * 用hashSet的方法，思路不变，用head保存当前子串首部在字符串中的位置，curr为当前字符位置，ans保存并更新最大子串长度
 * 用set和map的不同在于：
 * 1. set里只存储一个值，而非map存储的键值对，本题中用set存储出现过的字符，不再保存出现的位置
 * 2. set中不允许重复的值出现（对于本题无用）
 * 因为每个旧子串结束，都会从head开始remove()直到新的子串开头，所以循环过程中当前子串的长度始终等于set.size()
 */
class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashSet<Character> set = new HashSet<>();
        int head = 0, curr = 0, ans = 0;
        while (curr < s.length()) {
            if (set.contains(s.charAt(curr))) {
                ans = Math.max(ans, set.size());
                set.remove(s.charAt(head++));
            } else 
                set.add(s.charAt(curr++));
        }
        return Math.max(ans, set.size()); // set.size()是最后一个子串的长度
    }
}

/**
 * 第一次复习，自己的代码，和第一段第一次做自己的代码几乎一模一样hhh，只是前面用的s.charAt()，后面转成数组访问的字符
 * 用map保存字符和下标的对应关系，遍历s中的字符，每到一个字符，先判断map中有没有这个字符
 * 如果没有，说明这个当前字符在已遍历的字符串部分都没出现，直接map.put(arr[i], i)记录字符出现
 * 如果有，从map中get该字符上次出现的下标，这时候有两种情况：
 * 1. 下标小于startIdx，则不属于当前子串，子串可以继续，用map.put(arr[i], i)将map中该字符的下标更新到当前子串范围内
 * 2. 下标大于等于startIdx，说明与当前子串的字符重复，子串需要在前一个字符处结束，计算子串的长度并更新maxLen、startIdx、map中该字符的下标
 * startIdx的更新：
 * 这里也有讲究，应该把startIdx更新为重复字符上次出现的下标的后一位，然后直接继续遍历，不需要从上一个子串首部的后一位开始遍历
 * Runtime: 4 ms, faster than 88.34%
 * Memory Usage: 38.9 MB, less than 89.75%
 */
class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap(); // mapping character and the index of its last appearance
        int maxLen = 0, startIdx = 0; // startIdx is the start of current substring
        char[] arr = s.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            if (map.getOrDefault(arr[i], -1) >= startIdx) {
                maxLen = Math.max(maxLen, i - startIdx);
                startIdx = map.get(arr[i]) + 1;
            }
            map.put(arr[i], i);
        }
        return Math.max(maxLen, arr.length - startIdx); // to count the substring that ends with "s"
    }
}