创建于2017-3-10
原文链接：https://leetcode.com/problems/longest-substring-without-repeating-characters/?tab=Description

1 题目

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.

2 题解

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        if len(s) <= 1:
            return len(s)
        start,m_start,m_end=0,0,0
        c_dic={s[0]:0}  #记录每个字符的位置
        
        for end in range(1,len(s)):  #err1：注意边界条件
            #print end
            pos = c_dic.get(s[end],-1)
            #print "pos[%s]=%s" % (s[end],pos)
            
            if pos != -1:
                m_len=m_end-m_start+1
                c_len=end-1-start+1  
                
                if c_len > m_len:
                    m_start=start
                    m_end=end-1  #当前字符要排除掉
                
                old_start=start
                start=c_dic[s[end]]+1    
                for i in range(old_start, start):  #不能从0开始清理，否则会有误清理
                    c_dic[s[i]]=-1
                c_dic[s[end]]=end   #err2：清空字典后，起点start要记得赋值
            
            elif end==len(s)-1:
                m_len=m_end-m_start+1
                c_len=end-start+1  
                if c_len > m_len:
                    m_start=start
                    m_end=end  #err3:接受当前end位置的字符，这是为了针对循环到最后一个字符的情况。
                    
            c_dic[s[end]]=end  #插入字符    
            #print "m_start=%s,m_end=%s,start=%s,end=%s,pos[%s]=%s" % (m_start,m_end,start,end,s[end],c_dic[s[end]])
            end+=1
        
        
        return m_end-m_start+1

这段代码，我改了很多遍，测试用例总是通不过。需要考虑许多边界条件，如注释所示的err*，是代码调试中发现出错的地方。
总得来说，仅仅是accept，但是代码不够简洁，逻辑也不是很清晰，出错率很高。

3 解析

1，用快慢指针start,end来记录当前的不重复子串。
2，每次判断当前子串是否最长，如果是，则更新最长串
3，其中用到哈希表dict来记录字符是否出现过，并在子串更新时用O(k)的时间更新hash表。总的时间复杂度应该是O(N^2)

4 扩展

扩展部分主要是参考网上的题解和解析

方法一：暴力算法

Approach #1 Brute Force [Time Limit Exceeded]
用i，j两个下标迭代所有的子串，然后逐个判断是否重复，并更新最长串。
这里有个知识点，习惯上都是开区间到闭区间的方式：[i，j）

Paste_Image.png

时间复杂度：O(N^3)
空间复杂度：O(K)

方法二：滑动窗口法

Approach #2 Sliding Window [Accepted]

这个方法和我的解法思路一样。但是比我的代码逻辑更清晰，不需要在一个循环中嵌套k次清理集合的操作。相反，仅仅是在一次循环中固定滑动一个O(1)的窗口位置。所以这是一个O(N)复杂度的算法。逻辑清晰，就不容易出现错误，不像我之前的代码需要反复调试bug。
时间复杂度：O(N)
空间复杂度：O(K)

修正后的python代码如下：

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        n=len(s)
        set={}
        ans,i,j=0,0,0
        
        while(i<n and j <n):
            pos = set.get(s[j],-1)
            if(pos==-1):
                set[s[j]]=j
                j+=1   #越过当前字符，到下一个位置
                ans=max(ans, j-i)
            else:
                set[s[i]]=-1  #从集合中排除掉已经遍历的字符，一直到当前j不在集合中为止
                i+=1
        return ans

知识点

• 滑动窗口（双指针）遍历的一种方法，用两个变量作为while循环条件，然后在循环体中控制指针移动。

代码很少，而且一次就通过测试，无bug。

方法三：滑动窗口法升级版

Approach #3 Sliding Window Optimized [Accepted]
在我的解答里面其实已经用到了，就是当找到重复的j时，新的非重复串一定是从上一个j+1开始，这样才能不包含重复的j。于是i的新值可以计算出来。但也不需要像我的代码那样，做O（k）次清理集合的操作，而是把每个出现的字符位置记下来，找到最大那个就可以了。
时间复杂度：O(N)
空间复杂度：O(K)

修正后的python代码如下：

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        n=len(s)
        set={}
        ans,i,j=0,0,0
        
        while(i<n and j <n):
            pos = set.get(s[j],-1)
            if(pos==-1 or pos < i): #由于上一个j的位置有记录，因此如果该位置在i之前，则认为i之后是不含该字符的。
                set[s[j]]=j
                j+=1   #越过当前字符，到下一个位置
                ans=max(ans, j-i)
            else:
                i=pos+1
        return ans
        

和原文的java代码有一定的出入，这里直接利用dict保留了最新的字符位置，而不必采用map来做。