最长不含重复字符的子字符串

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        maxlen = 0
        char_map = {}
        init = -1
        for i in range(0, len(s)):
            if s[i] in char_map:
                if s[i] in char_map:
                    index = max(init, char_map[s[i]])
                    maxlen = max(maxlen, i - index)
                init = max(init, char_map[s[i]])
                char_map[s[i]] = i
            else:
                maxlen = max(maxlen, i - init)
                char_map[s[i]] = i
        return maxlen

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param s string字符串 
# @return int整型
#
class Solution:
    def lengthOfLongestSubstring(self , s: str) -> int:
        # write code here


        if s == " ":
            return 1
        #定义双指针，start用于指示最大字符串的头索引， end用于指示尾部索引
        start = 0
        end = 1

        #定义最长字符串的头索引和尾部索引
        max_start = 0
        max_end   = 1

        maxlength = 0
        #初始化dp的列表，列表中存放最大字符串的长度
        dp = [ i  for i in range(len(s) ) ]

        #初始化dp数组，当下标为0时表示的是下标为0的情况下，最大字符串的长度，这里肯定为1，因为前面没有字符串了    
        dp[0]=1
        

        #dp i存在俩种情况，
        #情况1：dpi以前面的字符串没有重复
        for i in range(1,len(s)):
            if s[i] not in s[start:end]:
                dp[i]=dp[i-1]+1
                end += 1
        #情况2：dpi以前的字符串重复了，
        #找到重复的位置，start重新在重复位置的基础上+1
        #end的值加1
            else:
                index = s[start:end].find(s[i])
                start = start + index + 1
                end +=1
        
            if end - start > max_end - max_start:
                max_start = start
                max_end   = end
        
            maxlength = max(maxlength,end-start)
        print(dp)
        return maxlength

class Solution:
    def lengthOfLongestSubstring(self , s: str) -> int:
        #哈希表记录窗口内非重复的字符
        n = len(s)
        ss = set()
        left = right = length = maxlength = 0
        while right <= n - 1:
            if s[right] not in ss:
                ss.add(s[right])
                length += 1
                maxlength = max(length,maxlength)
                right += 1
            else:
                while s[right] in ss:
                    ss.remove(s[left])
                    left += 1
                    length -= 1
                ss.add(s[right])
                right += 1
                length += 1
        return maxlength

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param s string字符串 
# @return int整型
#
from queue import deque
class Solution:
    def lengthOfLongestSubstring(self , s: str) -> int:
        # write code here
        q = deque()
        c = 0
        for x in s:
            if x in q:
               l = len(q)
               if c < l:
                  c = l
               while True:
                  if x == q.popleft():
                     break
            q.append(x)
        l = len(q)
        if c < l:
           c = l
        return c