leetcode3

 public class Solution
     {
         public int LengthOfLongestSubstring(string s)
         {
             var dic = new Dictionary<char, int>();
             var maxLength = ;
             for (int i = ; i < s.Length; i++)
             {
                 var c = s[i];
                 if (!dic.ContainsKey(c))
                 {
                     dic.Add(c, i);
                 }
                 else
                 {
                     i = dic[c];
                     var curLen = dic.Count;
                     if (maxLength < curLen)
                     {
                         maxLength = curLen;
                     }
                     dic.Clear();
                 }
             }

             var lastLen = dic.Count;
             if (maxLength < lastLen)
             {
                 maxLength = lastLen;
             }
             return maxLength;
         }
     }

这种解决方案思想是比较好的，但是实际的代码却引入了不必要的开销（如dic.Count的计算，dic.Clear()的处理等问题），因此执行效果不如普通的滑动窗口。

下面给出另一种执行效率更高的写法：

 public class Solution
     {
         public int LengthOfLongestSubstring(string s)
         {
             int n = s.Length, ans = ;
             Dictionary<char, int> map = new Dictionary<char, int>();
             for (int j = , i = ; j < n; j++)
             {
                 if (map.ContainsKey(s[j]))
                 {
                     //i记录没有出现重复字符的子串的起始索引
                     i = Math.Max(map[s[j]], i);

                     //map记录每一个字符，当前循环为止的最大的索引+1,(+1是为方便计算)
                     map[s[j]] = j + ;
                 }
                 else
                 {
                     //新字符第一次出现，记录其索引+1,(+1是为方便计算)
                     map.Add(s[j], j + );
                 }
                 ans = Math.Max(ans, j - i + );
             }
             return ans;
         }
     }

在补充一份python的实现：

 class Solution:
     def lengthOfLongestSubstring(self, s: str) -> int:
         n = len(s)
         if n == :
             return
         if n == :
             return
         dic = {}
         maxlength =
         left =
         right =
         while left < n:
             right = left
             while right < n:
                 if s[right] in dic and dic[s[right]] >= left:
                     length = right - left
                     maxlength = max(maxlength,length)
                     left = dic[s[right]] +
                     dic[s[right]] = right
                     right +=
                 else:
                     dic[s[right]] = right
                     right += 

                 if right == n:
                     length = right - left
                     maxlength = max(maxlength,length)
                     return maxlength
         maxlength = max(maxlength,right-left)
         return maxlength