2021.5.4

題目：

給定一個字串，請你找出其中不含有重複字元的最長子串的長度。

難度：中等

示例：

輸入: s = "pwwkew"
輸出: 3
解釋: 因為無重複字元的最長子串是"wke"，所以其長度為 3。
  請注意，你的答案必須是 子串 的長度，"pwke"是一個子序列，不是子串。

力扣題目地址：

https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

解題思路：

本文思路摘自力扣大佬思路

第一步：解法一

我們最開始肯定是先想到用一個函式去判斷子串是否有重複，然後再用一個函式迴圈窮舉所有子串，找出最長子串。思路是沒問題的，但是三個for迴圈在資料大的時候會超時。

圖解：i其實相當於左指標，j相當於右指標。

public int lengthOfLongestSubstring(String s) {
    int n = s.length();
    int ans = 0;//儲存當前得到滿足條件的子串的最大值
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n+1; j++) //之所以 j< n+1，是因為我們子串是 [i,j),左閉右開.就像上面圖片一樣，子串最長為3，所以j需要比它多1才能表示出來
            if (allUnique(s, i, j)) ans = Math.max(ans, j - i); //更新 ans
    return ans;
}

public boolean allUnique(String s, int start, int end) {
    Set<Character> set = new HashSet<>();//初始化 hash set
    for (int i = start; i < end; i++) {//遍歷每個字元
        Character ch = s.charAt(i);
        if (set.contains(ch)) return false; //判斷字元在不在 set 中
        set.add(ch);//不在的話將該字元新增到 set 裡邊
    }
    return true;
}
 

第二步：解法二

遺憾的是上邊的演算法沒有通過 leetCode，時間複雜度太大，造成了超時。我們怎麼來優化一下呢？

上邊的演算法中，我們假設當 i 取 0 的時候，

• j 取 1，判斷字串 str[0,1) 中有沒有重複的字元。
• j 取 2，判斷字串 str[0,2) 中有沒有重複的字元。
• j 取 3，判斷字串 str[0,3) 中有沒有重複的字元。
• j 取 4，判斷字串 str[0,4) 中有沒有重複的字元。

做了很多重複的工作，因為如果 str[0,1) 中沒有重複的字元，我們不需要再判斷整個字串 str[0,2) 中有沒有重複的字元，而只需要判斷 str[2] 在不在 str[0,1) 中，不在的話，就表明 str[0,2) 中沒有重複的字元

此外，我們的 j 也不需要取 j + 1，而只需要從當前的 j 開始就可以了。

綜上，其實整個關於 j 的迴圈我們完全可以去掉了，此時可以理解變成了一個「滑動視窗」。

整體就是橘色視窗在依次向右移動。

判斷一個字元在不在字串中，我們需要可以遍歷整個字串，遍歷需要的時間複雜度就是 O（n），加上最外層的 i 的迴圈，總體複雜度就是 O（n²）。我們可以繼續優化，判斷字元在不在一個字串，我們可以將已有的字串存到 Hash 裡，這樣的時間複雜度是 O（1），總的時間複雜度就變成了 O（n）。

public class Solution {
    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) {
            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;
    }
}

時間複雜度：在最壞的情況下，while 迴圈中的語句會執行 2n 次，例如 abcdefgg，開始的時候 j 一直後移直到到達第二個 g 的時候固定不變 ，然後 i 開始一直後移直到 n ，所以總共執行了 2n 次，時間複雜度為 O（n）。

空間複雜度：和上邊的類似，需要一個 Hash 儲存子串，所以是 O（min（m，n））。到這裡，我們的解法就已經算湊合了，但是還有可以進行優化的地方，且看解法三

第三步：解法三

繼續優化，我們看上邊的演算法的一種情況。

當 j 指向的 c 存在於前邊的子串 abcd 中，此時 i 向前移到 b ,此時子串中仍然含有 c，還得繼續移動，所以這裡其實可以優化。我們可以一步到位，直接移動到子串 c 的位置的下一位！這種想法和在串的模式匹配裡面用到的思想是很相似的。

實現這樣的話，我們將 set 改為 map ，將字元存為 key ，將對應的下標存到 value 裡就實現了。這裡的i代表左指標，j代表右指標

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n=s.length();
        int ans=0;
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0,j=0;j<n;j++){
            if(map.containsKey(s.charAt(j))){
                i=Math.max(map.get(s.charAt(j))+1,i); //當前字元包含在當前有效的子段中，那麼我們就需要更新左指標。（比如像上面圖片一樣，j指標指向c的時候（abcdc），當前字元在有效欄位中，那麼我們需要把i指標移動到第一個c的右邊，也就是d的位置，所以是s.charAt(j))+1）
            }
            ans=Math.max(ans,j-i+1);
            map.put(s.charAt(j),j);
        }
        return ans;
    }
}

與解法二相比

由於採取了 i 跳躍的形式，所以 map 之前存的字元沒有進行 remove ，所以 if 語句中進行了Math.max ( map.get ( s.charAt ( j ) ) , i )，要確認得到的下標不是 i 前邊的。所以取得範圍在[i，j]之間。

還有個不同之處是 j 每次迴圈都進行了自加 1 ，因為 i 的跳躍已經保證了 str[ i , j] 內沒有重複的字串，所以 j 直接可以加 1 。而解法二中，要保持 j 的位置不變，因為不知道和 j 重複的字元在哪個位置。

最後個不同之處是， ans 在每次迴圈中都進行更新，因為 ans 更新前 i 都進行了更新，已經保證了當前的子串符合條件，所以可以更新 ans 。而解法二中，只有噹噹前的子串不包含當前的字元時，才進行更新。

時間複雜度：我們將 2n 優化到了 n ，但最終還是和之前一樣，O（n）。

空間複雜度：也是一樣的，O（min（m，n)）。