Tips:所有代码实现包含三种语言(java、c++、python3)
题目
Given a string, find the length of the longest substring without repeating characters.
给定字符串,找到最大无重复子字符串。
样例
Input: "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.
Input: "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.
Input: "pwwkew"
Output: 3
Explanation: 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.
解题
首先看到:
输入:一个字符串
输出:最大无重复子字符串的长度
优秀的程序猿很快理解了问题,并且快速给出了第一个思路:
计算以字符串中的每个字符作为开头的子字符串的最大长度,然后选取最大长度返回;
那么问题就变了简单了:求解字符串中以某个字符开头的最大无重复子字符串 ,这里我们借助 Set 实现判断子字符串中是否无重复。
具体步骤如下:
- 遍历字符串中每个字符,并执行步骤2;
- 构建一个 Set,用于记录子字符串所包含字符,逐个添加此字符之后的字符进入 Set,直至 Set 中已包含此字符;
- 比较所有无重复子字符串的长度,返回最大值;
//java
// Runtime: 77 ms, faster than 17.83% of Java online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 39.4 MB, less than 19.93% of Java online submissions for Longest Substring Without Repeating Characters.
public int lengthOfLongestSubstring(String s) {
if(s.length()==0) return 0;
if(s.length()==1) return 1;
char[] schars = s.toCharArray();
int max = 0;
for(int i = 0; i < schars.length; i++){
HashSet<Character> curSet = new HashSet<Character>();
int j = i;
for(; j < schars.length; j++){
if(curSet.contains(schars[j])){
break;
}
curSet.add(schars[j]);
}
max = Math.max(max, j-i);
}
return max;
}
// c++
// Runtime: 900 ms, faster than 6.82% of C++ online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 271 MB, less than 5.03% of C++ online submissions for Longest Substring Without Repeating Characters.
int lengthOfLongestSubstring(string s) {
if(s.length()==0) return 0;
if(s.length()==1) return 1;
int result = 0;
for(int i = 0; i < s.length() - result; i++){
unordered_set<char> curSet;
int j = i;
for(; j < s.length(); j++){
if(curSet.find(s[j]) != curSet.end()){
break;
}
curSet.insert(s[j]);
}
result = max(result, j-i);
}
return result;
}
# python3
# Runtime: 2456 ms, faster than 5.01% of Python3 online submissions for Longest Substring Without Repeating Characters.
# Memory Usage: 13.4 MB, less than 5.05% of Python3 online submissions for Longest Substring Without Repeating Characters.
def lengthOfLongestSubstring(self, s: str) -> int:
if len(s) == 0: return 0
if len(s) == 1: return 1
result = 0
i = 0
while i < len(s) - result:
j = i
cur_list = []
while j < len(s):
if s[j] in cur_list:
break
cur_list.append(s[j])
j+=1
result = max(result, len(cur_list))
i+=1
return result
可以看到,虽然算法是正确的,但是 runtime 表现很差,优秀的程序猿不满足于此;
再审视一遍题目:
给定字符串,找到最大无重复子字符串
优秀的程序猿敏锐的捕捉到了两个关键词 “找到”、“子字符串” ,脑子里猛地蹦出来一个思路:滑动窗口(Sliding Window) ;
滑动窗口(Sliding Window) :设立两个游标,分别指向字符串中的字符,两个游标作为窗口的左右边界用来表示窗口,也就是子字符串;
对于滑动窗口(Sliding Window),我们必须明确以下几点:
- 窗口代表什么?
- 左右边界代表什么?
- 左右边界的滑动时机?
首先我们知道,在本题中,窗口代表的就是无重复子字符串,左右边界分别代表子字符串的两端;
对于滑动时机,在本题中,我们限定右边界的滑动为主滑动,也就是说,右边界的滑动为从字符串最左端至最右端;而对于左边界,其滑动跟随右边界的滑动,每当右边界发生滑动,那么判断新纳入字符是已存在当前窗口中,如不存在,左边界不动,如存在,则将左边界滑动至窗口中此已存在字符之后,可看出此操作保证了窗口中一定不存在重复字符;
每当窗口发生变化,更新最大窗口长度,当右边界滑动至字符串最右端时结束并返回最大长度;
随着右边界的滑动,我们使用 map 记录每个字符最后出现的位置,以便于左边界的滑动更新;
// java
// Runtime: 17 ms, faster than 96.07% of Java online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 39.1 MB, less than 23.13% of Java online submissions for Longest Substring Without Repeating Characters.
public int lengthOfLongestSubstring(String s) {
if(s == null || s.length()==0) return 0;
if(s.length()==1) return 1;
char[] schars = s.toCharArray();
Map<Character, Integer> sMap = new HashMap<>();
int max = 0;
int start=0, end=0;
for(; end < schars.length; end++){
if(sMap.containsKey(schars[end])){
start = Math.max(start, sMap.get(schars[end]));
}
sMap.put(schars[end], end+1);
max = Math.max(max, end-start+1);
}
return max;
}
// c++
// Runtime: 28 ms, faster than 67.81% of C++ online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 16.3 MB, less than 52.86% of C++ online submissions for Longest Substring Without Repeating Characters.
int lengthOfLongestSubstring(string s) {
if(s.length()==0) return 0;
if(s.length()==1) return 1;
int result = 0;
unordered_map<char, int> sMap;
int start=0, end=0;
for(; end < s.length(); end++){
if(sMap.count(s[end])){
start = max(start, sMap[s[end]]);
}
sMap[s[end]] = end+1;
result = max(result, end-start+1);
}
return result;
}
# python3
# Runtime: 92 ms, faster than 63.67% of Python3 online submissions for Longest Substring Without Repeating Characters.
# Memory Usage: 13.5 MB, less than 5.05% of Python3 online submissions for Longest Substring Without Repeating Characters.
def lengthOfLongestSubstring(self, s: str) -> int:
if len(s) == 0: return 0
if len(s) == 1: return 1
result = 0
s_dict = {}
start = 0
for idx, ch in enumerate(s):
if ch in s_dict:
start = max(start, s_dict[ch])
s_dict[ch] = idx+1
result = max(result, idx-start+1)
return result
runtime 表现不错,不过优秀的程序猿觉得任有瑕疵,既然我们处理的数据被限定为字符串,那我们其实没必要使用 map ,使用长度为 256 的数组就完全可以起到 map 的作用;
优秀的程序猿又欢快的修改了答案
// java
// Runtime: 15 ms, faster than 99.32% of Java online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 40 MB, less than 13.57% of Java online submissions for Longest Substring Without Repeating Characters.
public int lengthOfLongestSubstring(String s) {
if(s == null || s.length()==0) return 0;
if(s.length()==1) return 1;
char[] schars = s.toCharArray();
int[] lastIndex = new int[256];
int max = 0;
int start = 0, end = 0;
for(; end < schars.length; end++){
start = Math.max(start, lastIndex[(int)schars[end]]);
lastIndex[(int)schars[end]] = end+1;
max = Math.max(max, end-start+1);
}
return max;
}
// c++
// Runtime: 16 ms, faster than 99.18% of C++ online submissions for Longest Substring Without Repeating Characters.
// Memory Usage: 14.6 MB, less than 97.14% of C++ online submissions for Longest Substring Without Repeating Characters.
int lengthOfLongestSubstring(string s) {
if(s.length()==0) return 0;
if(s.length()==1) return 1;
int result = 0;
int lastIndex[256];
memset(lastIndex, 0x00000000, sizeof(int)*256);
int start=0, end=0;
for(; end < s.length(); end++){
start = max(start, lastIndex[s[end]]);
lastIndex[s[end]] = end+1;
result = max(result, end-start+1);
}
return result;
}
# python3
# Runtime: 92 ms, faster than 63.67% of Python3 online submissions for Longest Substring Without Repeating Characters.
# Memory Usage: 13.5 MB, less than 5.05% of Python3 online submissions for Longest Substring Without Repeating Characters.
def lengthOfLongestSubstring(self, s: str) -> int:
if len(s) == 0: return 0
if len(s) == 1: return 1
result = 0
lastIndex = [0 for i in range(256)]
start = 0
for idx, ch in enumerate(s):
start = max(lastIndex[ord(ch)], start)
lastIndex[ord(ch)] = idx+1
result = max(result, idx-start+1)
return result
优秀的程序猿又严谨得审视了几遍代码,满意得合上了电脑。。。