leetcode3

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

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

 

在补充一份python的实现：

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        n = len(s)
        if n == 0:
            return 0
        if n == 1:
            return 1
        dic = {}
        maxlength = 1
        left = 0
        right = 0
        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]] + 1
                    dic[s[right]] = right
                    right += 1
                else:
                    dic[s[right]] = right
                    right += 1
                    
                if right == n:
                    length = right - left
                    maxlength = max(maxlength,length)
                    return maxlength
        maxlength = max(maxlength,right-left)
        return maxlength

 

Java版本：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int l = s.length();
        if(l == 0){
            return 0;
        }else if(l == 1){
            return 1;
        }else{
            int i = 0;
            int j = 0;
            HashMap<Character,Integer> map = new HashMap<Character,Integer>();
            int maxLength = 0;
            while(j < l){
                char c = s.charAt(j);
                if(map.containsKey(c)){
                    int curLength = j - i;
                    maxLength = Math.max(curLength,maxLength);
                    
                    int repeatIndex = map.get(c);
                    for(int k=i;k<=repeatIndex;k++) {
                        Character rKey = s.charAt(k);
                        map.remove(rKey);
                    }
                    i = repeatIndex + 1;
                    map.put(c, j);
                }else{
                    map.put(c, j);
                }
                j++;
            }
            maxLength = Math.max(j-i,maxLength);
            return maxLength;
        }
    }
}