LeetCode3. Longest Substring Without Repeating Characters

（0）前言

　　本来不打算在博客里面记录自己刷LeetCode的经过。做了几道题目以后发现可以AC倒是不假，但是使用的方法在时间效率上平均只能打败50%左右的用户。因而决定还是记录一下，不该小瞧这些基础的题目，它们自有存在的价值。

（一）题意

题目链接：https://leetcode.com/problems/longest-substring-without-repeating-characters/

3. Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

————————————————————————————————————————————————————————————————————————————

（二）题解

（1）普通解法-O(n²）

把所有的情况都枚举一遍，寻找最长不含重复字母的字串。借助一个bool数组，快速判断是否存在重复。代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length();
        bool vis[200];
        int ans = 0,sublen;
        for(int i = 0; i < len; i++)
        {
            memset(vis,0,sizeof vis);
            sublen = 0;
            for(int j = i; j < len; j++)
            {
                if(!vis[s[j]])
                {
                    vis[s[j]] = 1;
                    sublen++;
                }
                else
                {
                    break;
                }
            
            }
            if(sublen > ans)    ans = sublen;
        }
        return ans;
    }
};

（2）优化算法1-O(2n)

上面那个解法是最普通的想法。可以解决这个问题，但是效率不高，因为每一次j都是从i逐个往后移动，而i也是逐个移动的，这导致进行了很多次重复的判断。

而实际上在上一轮中已经做过判断的子串可以继续加以利用。于是引入了set的数据结构。这种方法叫做滑动窗口法

set是集合，包含的元素相互都是不重复的。

因而只要扫一遍字符串就可以解决问题了，但是i和j最坏情况下会重复扫描了同一个字符，所以时间复杂度是2n。

代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length();
        set<char> sub;
        int i = 0, j = 0,ans = 0;
        //int sublen = 0;
        while(i < len && j < len)
        {
            if(sub.find(s[j]) == sub.end())
            {
                sub.insert(s[j]);
                j ++;
                if((j - i) > ans)
                    ans = j - i;
            }
            else
            {
                sub.erase(sub.find(s[i]));
                i++;
            }
        }
        return ans;
    }
};

但是第一种实现用时36ms，第二种实现用时132ms。我怀疑是set的引入花费了时间。set要用O(logn)的时间查找、删除、增加元素。

所以改成了用hash的方法，使用bool类型的vis数组标记字符是否出现过.

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length();
        int i = 0, j = 0,ans = 0;
        bool vis[300];
        memset(vis,0,sizeof vis);
        while(i < len && j < len)
        {
            if(!vis[s[j]])
            {
                vis[s[j]] = 1;
                j++;
            }
            else
            {
                vis[s[i]] = 0;
                if(j - i > ans) 
                    ans = j - i;
                i++;
            }
        }
        if(j - i > ans) 
                    ans = j - i;
        return ans;
    }
};

（3）优化算法2-O(n)

是对滑动窗口的一种优化，不仅记录已经判断过的元素，还记录该元素对应的下标。

如果j’是与j位置相同的字符，那么下一次i只需要从j’+1开始判断即可，不需要重复[i+1,j']之间的这些判断。

代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        cout<<endl;
        int len = s.length();
        int i = 0, j = 0,ans = 0;
        int vis[300];
        for(int k = 0; k < 300; k++)
            vis[k] = -1;
        while(i < len && j < len)
        {
            if(vis[s[j]] == -1 || vis[s[j]] < i)
            {
            }
            else 
            {
                if(j - i > ans) 
                    ans = j - i;
                i = vis[s[j]] + 1;
            }
            vis[s[j]] = j;
            j++;
        }
        if(j - i > ans) 
            ans = j - i;
        return ans;
    }
};

三种方法是一个循序渐进的过程，纯纯思考这个过程对我来说还是有些煎熬的，虽然道理是很显然的，借助图来说明一下，

第一种方法

第二种方法

第三种方法