从0开始的leetCode: Longest Substring

我的解法：

public int lengthOfLongestSubstring(String s) {
        int num;
        int maxsize;
        ArrayList<Character> arrayList =new ArrayList<>();
        if (s.length()>0){//考虑空串
            arrayList.add(s.charAt(0));
            num=0;
        }else{
            num=1;
        }
        maxsize=num;
        for (int i = 1; i < s.length(); i++) {
            if (arrayList.contains(s.charAt(i))){
                maxsize=num>maxsize?num:maxsize;
                arrayList.clear();
                num=0;
            }else {
                ++num;
                arrayList.add(s.charAt(i));
            }
        }
        maxsize=num>maxsize?num:maxsize;
        return maxsize;
    }

错因（我的想法）：此题就像字符串匹配一样，要么生成一个数组存储可跳过的数目，要么就用一个j来临时存储如果出现重复时，应该判断的下一个子串的头的位置。

高票答案如下：

 public int lengthOfLongestSubstring(String s) {
        if (s.length()==0) return 0;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int max=0;
        for (int i=0, j=0; i<s.length(); ++i){
            if (map.containsKey(s.charAt(i))){
                j = Math.max(j,map.get(s.charAt(i))+1);
            }
            map.put(s.charAt(i),i);
            max = Math.max(max,i-j+1);
        }
        return max;
    }

---

滑动窗口：

在原始的蛮力法（字符串匹配）中，我们重复检查了是否含有冗余字符，这是不必要的。如果一个（索引从i到j-1）子串Sij已经被检测出了没有冗余，那么只需要接着检查s[j]是否出现在了子串Sij中。

那么要检查冗余，一种方法是扫描子串（复杂度O(n)）。另一种方法是用HashSet作为一个滑动窗口，其搜索的复杂度为O(1)。滑动窗口是左开右闭的，i.e.[i, j) 。如果向左移动一个元素则变为[i+1, j+1)。

回到我们的问题中，我们使用HashSet将字符串存入窗口中[i,j)，初始化i=j。如果字符没有在HashSet里，则j朝右移（i不变），直到S[j]已经包含在了HashSet里（现在HashSet里存储的是Sij），我们可以知道这个S[j]是冗余的。现在Sij是从i开始的，如果我们把这个i遍及从1到n,我们可以得到答案。（如何遍及呢？只需删除第i个后（子串第1个），再次判断j是否包含在了HashSet里，其复杂度为O（2n）=O（n））

public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            // try to extend the range [i, j]
            if (!set.contains(s.charAt(j))){
                set.add(s.charAt(j++));
                ans = Math.max(ans, j - i);
            }
            else {
                set.remove(s.charAt(i++));
            }
        }
        return ans;
    }

 

---

滑动窗口优化：

实际上，不用使用一个Set来分辨一个字符是否已经被包括，我们可以使用一个Map来存储字符和他的索引。这样做是因为可以跳过已经重复的字符。

具体说明如下：如果S[j]已经在Sij（范围i到j-1）中重复，不妨假设S[j]在位置k上重复。那么只需要跳过从i到k的字符即可，即令i=k+1

public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); // current index of character
        // try to extend the range [i, j]
        for (int j = 0, i = 0; j < n; j++) {
            if (map.containsKey(s.charAt(j))) {
                i = Math.max(map.get(s.charAt(j)), i);
            }
            ans = Math.max(ans, j - i + 1);
            map.put(s.charAt(j), j + 1);
        }
        return ans;
    }

---