Leetcode 3 Longest Substring Without Repeating Characters

windliang發表於2019-03-03

leetcode.windliang.cc/ 第一時間釋出

題目描述(中等難度)

Leetcode 3 Longest Substring Without Repeating Characters

給定一個字串,找到沒有重複字元的最長子串,返回它的長度。

解法一

簡單粗暴些,找一個最長子串,那麼我們用兩個迴圈窮舉所有子串,然後再用一個函式判斷該子串中有沒有重複的字元。

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; j++) //之所以 j<= n,是因為我們子串是 [i,j),左閉右開
            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;
}
複製程式碼

時間複雜度:兩個迴圈,加上判斷子串滿足不滿足條件的函式中的迴圈,O(n³)。

空間複雜度:使用了一個 set,判斷子串中有沒有重複的字元。由於 set 中沒有重複的字元,所以最長就是整個字符集,假設字符集的大小為 m ,那麼 set 最長就是 m 。另一方面,如果字串的長度小於 m ,是 n 。那麼 set 最長也就是 n 了。綜上,空間複雜度為 O(min(m,n))。

解法二

遺憾的是上邊的演算法沒有通過 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,3) 中沒有重複的字元,我們不需要再判斷整個字串 str[0,4) 中有沒有重複的字元,而只需要判斷 str[3] 在不在 str[0,3) 中,不在的話,就表明 str[0,4) 中沒有重複的字元。

如果在的話,那麼 str[0,5) ,str[0,6) ,str[0,7) 一定有重複的字元,所以此時後邊的 j 也不需要繼續增加了。i ++ 進入下次的迴圈就可以了。

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

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

Leetcode 3 Longest Substring Without Repeating Characters

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

判斷一個字元在不在字串中,我們需要可以遍歷整個字串,遍歷需要的時間複雜度就是 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))。

解法三

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

Leetcode 3 Longest Substring Without Repeating Characters

當 j 指向的 c 存在於前邊的子串 abcd 中,此時 i 向前移到 b ,此時子串中仍然含有 c,還得繼續移動,所以這裡其實可以優化。我們可以一步到位,直接移動到子串 c 的位置的下一位!

Leetcode 3 Longest Substring Without Repeating Characters

實現這樣的話,我們將 set 改為 map ,將字元存為 key ,將對應的下標存到 value 裡就實現了。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); 
        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);//下標 + 1 代表 i 要移動的下個位置
        }
        return ans;
    }
}
複製程式碼

與解法二相比

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

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

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

時間複雜度:我們將 2n 優化到了 n ,但最終還是和之前一樣,O(n)。

空間複雜度:也是一樣的,O(min(m,n))。

解法四

和解法三思路一樣,區別的地方在於,我們不用 Hash ,而是直接用陣列,字元的 ASCII 碼值作為陣列的下標,陣列儲存該字元所在字串的位置。適用於字符集比較小的情況,因為我們會直接開闢和字符集等大的陣列。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        int[] index = new int[128];   
        for (int j = 0, i = 0; j < n; j++) {
            i = Math.max(index[s.charAt(j)], i);
            ans = Math.max(ans, j - i + 1);
            index[s.charAt(j)] = j + 1;//(下標 + 1) 代表 i 要移動的下個位置
        }
        return ans;
    }
}
複製程式碼

和解法 3 不同的地方在於,沒有了 if 的判斷,因為如果 index[ s.charAt ( j ) ] 不存在的話,它的值會是 0 ,對最終結果不會影響。

時間複雜度:O(n)。

空間複雜度:O(m),m 代表字符集的大小。這次不論原字串多小,都會利用這麼大的空間。

總結

綜上,我們一步一步的尋求可優化的地方,對演算法進行了優化。又加深了 Hash 的應用,以及利用陣列巧妙的實現了 Hash 的作用。

相關文章