題目連結：https://leetcode.com/problems/longest-substring-without-repeating-characters/

要求最長不重複子字串而不是子序列

思路一：

最先想到的就是暴力解法，就是將所以長度大於2的子字串都檢測一遍，在對每個子字串檢測時，需要一個數據結構來儲存字元出現的資訊，並且當某個子串出現重複時，後續包含該子串的字串就不需要檢查了。上程式碼;

public static int lengthOfLongestSubstring(String s) {
        if(s.length()==0)
            return 0;

        int ret=1;
        for(int i=0;i<s.length()-1;i++)
        {
            for(int j=i+1;j<s.length();j++)
            {
                int[] record=new int[95];
                int k=i;
                for(;k<j+1;k++)
                {
                    if(record[s.charAt(k)-' ']==0)
                        record[s.charAt(k)-' ']++;
                    else
                        break;
                }
                if(k<j+1)
                    break;
                ret=Math.max(ret,j-i+1);
            }
        }
        return ret;
    }
 

暴力解法的思想十分樸素直接但是執行效率較低，還好AC了。

思路二：

思路一的子串檢查是存在大量重複的，可以使用滑動視窗法。滑動視窗是一種常用於陣列和字串演算法問題的抽象概念，滑動視窗是由 來限定，字串檢查重複可以使用HashSet。

public static int lengthOfLongestSubstring(String s) {
        if(s.length()==0 || s==null)
            return 0;
        HashSet<Character> hs=new HashSet();
        int i=0,j=1,ret=1,n=s.length();
        while(i<n && j<n)
        {
            if(!hs.contains(s.charAt(j)))
            {
                j++;
                hs.add(s.charAt(j));
            }
            else
            {
                hs.remove(s.charAt(i));
                i++;
            }
            ret=Math.max(ret,j-i+1);
        }
        return ret;
    }
 

思路三：

思路二中滑動視窗左側i在每次j遇到重複只是向後移動一格，移動後的while檢查和ret=Math.max(ret,j-i+1)這一步存在冗餘，可以直接跳到下一個s[i]出現位置的下一個位置上

public static int lengthOfLongestSubstring2(String s) {
        if(s.length()==0 || s==null)
            return 0;
        HashMap<Character,Integer> hm=new HashMap();
        int i=0,j=0,n=s.length(),ret=1;
        while(i<n && j<n)
        {
            if(hm.containsKey(s.charAt(j)))
            {
                i=Math.max(i,hm.get(s.charAt(j)));
            }
            ret=Math.max(ret,j-i+1);

            hm.put(s.charAt(j),j+1);
            j++;
        }
        return ret;
    }
 

思路四：

因為字符集是ASCII集合，數量十分有限，所以採用思路一里面的檢查子串重複的記錄表的方法，index陣列記錄下一個s[i]出現的位置索引的下一個位置，這個方法是看的Solutions裡面的解答，感覺吸收結合了思路一和思路三在儲存和搜尋上的優勢，達到了效率的最大化。

我們以小寫字母表為例手動執行程式碼感受一下其中的奧妙：以字串“pwwkew”為例子：

public static int lengthOfLongestSubstring3(String s)
    {
        int[] index=new int[128];
        int ret=1;
        for(int i=0,j=0;j<s.length();j++)
        {
            i=Math.max(i,index[s.charAt(j)]);
            ret = Math.max(ret,j-i+1);
            index[s.charAt(j)]=j+1;
        }
        return ret;
    }