一个力扣的题目:
给定一个字符串 s
,请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
示例 2:
输入: s = "bbbbb" 输出: 1 解释: 因为无重复字符的最长子串是 "b" ,所以其长度为 1。
示例 3:
输入: s = "pwwkew" 输出: 3 解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。 请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
提示:
0 <= s.length <= 5 * 104
s
由英文字母、数字、符号和空格组成
题解如下:
方法:滑动窗口
以字符串s = "abacda"为例,找出从每一个字符开始的,不包含重复字符的最长子串,那么其中最长的那个字符串即为答案。使用两个指针表示字符串中的某个子串(或窗口)的左右边界。使用一种数据结构来判断是否为重复的。常用的数据结构为哈希集合(即 C++ 中的 std::unordered_set,Java 中的 HashSet,Python 中的 set, JavaScript 中的 Set)。
代码1:抽象版
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 定义一个数组idx,用于记录字符在字符串中的最后出现位置
int idx[128] = {0}; //ASCII是128个,所以是128.
// 初始化左指针left,用于记录当前不含重复字符的子串的起始位置
int left = 0;
// 初始化变量len,用于记录当前不含重复字符的子串的最大长度
int len = 0;
// 遍历字符串s中的每个字符
for (int i = 0; i < s.size(); i++) {
// 更新左指针left的位置为当前字符s[i]上次出现位置的下一个位置和left中较大的那个
left = max(left, idx[s[i]]);
// 更新len的值为当前子串的长度和len中较大的那个
len = max(len, i - left + 1);
// 更新数组idx中字符s[i]的值为当前字符s[i]的位置加1
// 由于数组下标从0开始,为了与字符串下标保持一致,将位置加1保存
idx[s[i]] = i + 1;//这一行有点抽象,给我看不会了
}
// 返回不含重复字符的最长子串的长度
return len;
}
};
看不懂看这个例子:以字符串abacda为例子。
开始遍历字符串s = "abacda"
的每个字符:
-
当
i = 0
时,当前字符s[0]
是'a'
,在idx
数组中idx['a']
为0(因为初始时所有位置都是0),所以更新left
的值为0(max(0, 0)),更新len
的值为1(i - left + 1 = 0 - 0 + 1 = 1),并更新idx['a']
为1。(idx['a']其实a转换为ASCII码值了,其实还是哈希的思想
) -
当
i = 1
时,当前字符s[1]
是'b'
,在idx
数组中idx['b']
为0,所以更新left
的值为0(max(0, 0))因为是数组,0代表这字串是从第一个a开始的,更新len
的值为2(i - left + 1 = 1 - 0 + 1 = 2),并更新idx['b']
为2。 -
当
i = 2
时,当前字符s[2]
是'a'
,在idx
数组中idx['a']
为1,因为'a'
上次出现的位置是1(字符串的索引是从0开始的),所以更新left
的值为1(max(0, 1))1表示从第二个位置b,更新len
的值为2(i - left + 1 = 2 - 1 + 1 = 2),并更新idx['a']
为3(其实一直在记录一个字符最近出现的位置)。 -
当
i = 3
时,当前字符s[3]
是'c'
,在idx
数组中idx['c']
为0,所以更新left
的值为1(max(1, 0)),更新len
的值为3(i - left + 1 = 3 - 1 + 1 = 3),并更新idx['c']
为4。 -
当
i = 4
时,当前字符s[4]
是'd'
,在idx
数组中idx['d']
为0,所以更新left
的值为1(max(1, 0)),更新len
的值为4(i - left + 1 = 4 - 1 + 1 = 4),并更新idx['d']
为5。 -
当
i = 5
时,当前字符s[5]
是'a'
,在idx
数组中idx['a']
为3,所以更新left
的值为3(max(1, 3)),更新len
的值为3(i - left + 1 = 5 - 3 + 1 = 3),并更新idx['a']
为6。 -
遍历完整个字符串后,最终返回的
len
值为4,即不含重复字符的最长子串的长度为4,对应的子串是"bacd"
。
反正挺神奇,这样一种很朴素高明的解法展示了滑动窗口的思想,当你n个字符内没有重复的,而第n+1个和第1个重复了,其实一个窗口往前走一个仍然是n个字符内没有重复的,一直往前走,保存最大的就好了。
虽然这个很神奇,我感觉似懂非懂的。
本人用python写的和这个挺像,但是好懂一点:因为我的左指针left如果有重复字符是直接加1的,当前该重复字符的最新出现位置为右指针,上面的c++有点绕,但是看了两遍,我居然写的和它一样,笔记白写了。
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
n = len(s) # 获取字符串的长度
max_length = 0 # 用于记录最长不含重复字符的子串长度
left = 0 # 记录当前不含重复字符的子串的起始位置
char_index = {} # 字典,用于记录每个字符最后出现的位置
# 遍历字符串 s 中的每个字符
for right in range(n):
# 如果当前字符已经在 char_index 中存在,并且其最后出现的位置大于等于 left,
# 说明当前字符重复了,需要更新 left 的位置为上次该字符出现的下一个位置
if s[right] in char_index and char_index[s[right]] >= left:
left = char_index[s[right]] + 1
# 将当前字符的最后出现位置更新为 right
char_index[s[right]] = right
# 计算当前不含重复字符的子串的长度,并更新 max_length
max_length = max(max_length, right - left + 1)
# 返回最长不含重复字符的子串的长度
return max_length
代码2:使用set版
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 获取字符串s的长度
int len = s.size();
// 初始化结果变量为0,用于记录最长子串的长度
int res = 0;
// 初始化右指针r为0,用于记录当前不含重复字符的子串的结束位置
int r = 0;
// 使用无序集合unordered_set来存储当前窗口中出现过的字符,用于判断字符是否重复
unordered_set<char> st;
// 遍历字符串s中的每个字符
for (int i = 0; i < len; i++) {
// 移动右指针r,直到出现重复字符或者到达字符串末尾
while (r < len && !st.count(s[r])) {//count计数,当重复就为1,取反为0就会跳出
// 将字符s[r]插入到集合st中
st.insert(s[r]);
// 右指针r向右移动一位
r++;
}
// 更新最长子串的长度为当前子串的长度和res中较大的那个
res = max(res, r - i);
// 将字符s[i]从集合st中删除,以维持窗口内的字符都是不重复的
st.erase(s[i]);
}
// 返回最长子串的长度
return res;
}
};
比上个代码好理解不少,不解释了,两个指针移来移去,但是依旧有点难写,使用了set,其实还好,当然还有代码3。
代码3:朴素版
const int N = 5e4 + 10; // 定义常量N,题目要求,虽然这么大没必要吧可能
class Solution {
int a[N]; // 用来记录每个字符出现的个数
public:
int lengthOfLongestSubstring(string s) {
int res = 0; // 初始化结果变量为0,用于记录最长子串的长度
for (int i = 0, j = 0; i < s.size(); i++) { // 使用双指针i和j遍历字符串s,i是一直往右走的,j是记录起点的。
a[s[i]]++; // 记录字符s[i]出现的个数,还是哈希思想,s[i]是键。
while (a[s[i]] > 1) { // 当字符s[i]出现的个数大于1时,说明有重复字符
a[s[j]]--; // 将字符s[j]出现的个数减1
j++; // 左指针j向右移动
}
res = max(res, i - j + 1); // 更新最长子串的长度为当前子串的长度和res中较大的那个
}
return res; // 返回最长子串的长度
}
};
这个已经是最简单的了吧。
代码4:又快内存又少map版
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 哈希表记录字符最后出现的位置
unordered_map<char, int> hash;
int ans = 0; // 记录最长子串的长度
int left = 0; // 记录当前不含重复字符的子串的起始位置
int i; // 循环变量
// 遍历字符串s的每个字符
for (i = 0; i < s.length(); ++i) {
char cur = s[i]; // 获取当前字符
// 如果当前字符已经在哈希表中出现过
if (hash.count(cur)) {
// 更新最长子串的长度为当前子串的长度和ans中较大的那个
ans = max(ans, i - left);
// 更新left的值为当前字符上次出现位置的下一个位置和left中较大的那个
left = max(left, hash[cur] + 1);
}
// 更新哈希表中字符cur的值为当前位置i
hash[cur] = i;
}
// 返回最长子串的长度
return max(ans, i - left);
}
};
其实和set那个没啥区别,但是就是快,指针不是一个个移动了,右指针传送,所以快点。
总结:
总之,这几个代码思想都一样,但是写法不一样,故记录一下。
题目来源:. - 力扣(LeetCode)