一、需求
- 请从字符串中找出一个最长的不包含重复字符的子字符串,计算该最长子字符串的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
二、动态规划+哈希表
2.1 思路分析
- 定义状态dp[j]表示以字符s[j]为结尾的"最长不含重复字符的子字符串的最大长度",每个状态的起点满足2中所描述的;
- 固定右边界j,设字符s[j]左边距离最近的相同字符为s[i],即s[i] = s[j];
- 关于转移方程,①dp[j-1] < j - i时,dp[j] = dp[j-1] + 1;②dp[j-1] >= j - i时,dp[j] = j - i;
- 这个转移方程,更像是找规律,比如字符串为"1234"时,i 此时都不存在,故这种情况初始化 i 为负值,满足情况①;当字符串为"1001"时,当i = 0,j = 3时,满足①;当字符串为"1101"时,满足②相等的情况;当字符串为"1233"时,满足②大于的情况;
2.2 代码实现
/*
getOrDefault(key,default),HashMap中的一个方法,若集合中存在key,那么就返回对应的
value值,否则返回default
*/
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character,Integer> hm = new HashMap<>();
int res = 0;
if(s == null || s.length() == 0) return res;
int[] dp = new int[s.length()];
dp[0] = 1;
hm.put(s.charAt(0),0);
for(int j = 1; j < s.length(); j++) {
//map中没有key,则返回设置的-1,有则返回key对应的value
int i = hm.getOrDefault(s.charAt(j),-1);
if(dp[j-1] < j-i) {
dp[j] = dp[j-1] + 1;
} else {
dp[j] = j - i;
}
//更新hm值
hm.put(s.charAt(j),j);
res = Math.max(res,dp[j]);
}
return Math.max(res,1);
}
}
2.3 复杂度分析
- 时间复杂度为O(N),N为字符串的长度;
- 空间复杂度为O(N),dp数组占用O(N)大小的额外空间,而HashMap集合最多存储128个字节,即最大O(128),故总体空间复杂度为O(N);
三、动态规划+哈希表优化
3.1 思路分析
- 因为上述方法中dp[j]只与dp[j-1]及变量i,j有关,因此可用变量代替,从而节省空间,使得空间复杂度为O(1);
3.2 代码实现
/*
getOrDefault(key,default),HashMap中的一个方法,若集合中存在key,那么就返回对应的
value值,否则返回default
*/
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character,Integer> hm = new HashMap<>();
int res = 0;
int tmp = 0;;
for(int j = 0; j < s.length(); j++) {
int i = hm.getOrDefault(s.charAt(j),-1);
tmp = tmp < j-i ? tmp + 1 : j - i;
//更新hm值
hm.put(s.charAt(j),j);
res = Math.max(res,tmp);
}
return res;
}
}
四、动态规划+线性遍历
4.1 思路分析
- 这个方法和上面区别就是使用线性遍历来寻找距离字符s[j]最近的那个索引 i ,就是当遍历到s[j]时,初始化索引 i = j - 1,然后向左遍历 i ,一直到 s[i] = s[j];
4.2 代码实现
/*
getOrDefault(key,default),HashMap中的一个方法,若集合中存在key,那么就返回对应的
value值,否则返回default
*/
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character,Integer> hm = new HashMap<>();
int res = 0;
int tmp = 0;;
for(int j = 0; j < s.length(); j++) {
int i = j - 1;
while(i >= 0 && s.charAt(i) != s.charAt(j)) i--;
tmp = tmp < j-i ? tmp + 1 : j - i;
//更新hm值
hm.put(s.charAt(j),j);
res = Math.max(res,tmp);
}
return res;
}
}
4.3 复杂度分析
- 时间复杂度为
,其中外循环遍历字符串N次,内循环寻找索引 i 最坏情况下 j 次,因此时间复杂度为
;
- 空间复杂度为O(1),几个变量使用常数大小的额外空间;
五、双指针+哈希表(滑动窗口)
5.1 思路分析
- 这一次仍然使用哈希表记录距离字符s[j]最近的那个索引 i;
- 第一种方法是考虑了索引 i 位置的所有情况,第二种方法通过线性遍历寻找索引 i ,而这种方法通过双指针,将 i 视为左指针,通过更新使得在[i+1,j]区间内无重复字符;
- 那么如何更新左指针呢?一开始初始化 i < 0(比如到第一个字符时,其 i 不存在,故用负数表示),当遍历到字符s[j]时, 取出哈希表中距离字符s[j]最近的那个索引,将该索引与左指针 i 取最大值;
- 因为[i+1,j]区间内没有重复元素,故每轮更新j - i,最后返回最大值;
5.2 代码实现
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character,Integer> hm = new HashMap<>();
int res = 0;
int i = -1;
for(int j = 0; j < s.length(); j++) {
if(hm.containsKey(s.charAt(j))) {
i = Math.max(i,hm.get(s.charAt(j)));
}
hm.put(s.charAt(j),j);
res = Math.max(res,j-i);
}
return res;
}
}
5.3 复杂度分析
- 时间复杂度为O(N),其中N为字符串长度;
- 空间复杂度为O(1),哈希表最多存储128位,外加几个变量占用常数级别的额外空间;
六、学习地址
作者:Krahets