目录
一，无重复字符的最长字串
https://leetcode.cn/problems/longest-substring-without-repeating-characters/?plan=algorithms&plan_progress=gzwnnxs
1，滑动窗口
我们先用一个例子考虑如何在较优的时间复杂度内通过本题。
我们不妨以示例一中的字符串 abcabcbb 为例，找出从每一个字符开始的，不包含重复字符的最长子串，那么其中最长的那个字符串即为答案。对于示例一中的字符串，我们列举出这些结果，其中括号中表示选中的字符以及最长的字符串：
以 (a)bcabcbb 开始的最长字符串为 (abc)abcbb；
以 a(b)cabcbb 开始的最长字符串为 a(bca)bcbb；
以 ab(c)abcbb 开始的最长字符串为 ab(cab)cbb；
以 abc(a)bcbb 开始的最长字符串为 abc(abc)bb；
以 abca(b)cbb 开始的最长字符串为 abca(bc)bb；
以abcab(c)bb 开始的最长字符串为 abcab(cb)b；
以abcabc(b)b 开始的最长字符串为 abcabc(b)b；
以abcabcb(b) 开始的最长字符串为abcabcb(b)。
发现了什么？如果我们依次递增地枚举子串的起始位置，那么子串的结束位置也是递增的！这里的原因在于，假设我们选择字符串中的第k 个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置为 r_k 。那么当我们选择第k+1 个字符作为起始位置时，首先从 k+1 到 r_k的字符显然是不重复的，并且由于少了原本的第 k 个字符，我们可以尝试继续增大 r_k，直到右侧出现了重复字符为止。
这样一来，我们就可以使用「滑动窗口」来解决这个问题了：
我们使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的 r_k；
在每一步的操作中，我们会将左指针向右移动一格，表示 我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度；
在枚举结束后，我们找到的最长的子串的长度即为答案。
判断重复字符
在上面的流程中，我们还需要使用一种数据结构来判断 是否有重复的字符，常用的数据结构为哈希集合（即 C++ 中的 std::unordered_set，Java 中的 HashSet，Python 中的 set, JavaScript 中的 Set）。在左指针向右移动的时候，我们从哈希集合中移除一个字符，在右指针向右移动的时候，我们往哈希集合中添加一个字符。
至此，我们就完美解决了本题。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 哈希集合，记录每个字符是否出现过
unordered_set<char> occ;
int n = s.size();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
// 枚举左指针的位置，初始值隐性地表示为 -1
for (int i = 0; i < n; ++i) {
if (i != 0) {
// 左指针向右移动一格，移除一个字符
occ.erase(s[i - 1]);
}
while (rk + 1 < n && !occ.count(s[rk + 1])) {
// 不断地移动右指针
occ.insert(s[rk + 1]);
++rk;
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, rk - i + 1);
}
return ans;
}
};
复杂度分析
时间复杂度：O(N)，其中 N 是字符串的长度。左指针和右指针分别会遍历整个字符串一次。
空间复杂度：O(∣Σ∣)，其中 Σ 表示字符集（即字符串中可以出现的字符），∣Σ∣ 表示字符集的大小。在本题中没有明确说明字符集，因此可以默认为所有 ASCII 码在 [0,128) 内的字符，即 ∣Σ∣=128。我们需要用到哈希集合来存储出现过的字符，而字符最多有 ∣Σ∣ 个，因此空间复杂度为 O(∣Σ∣)。
二，字符串的排列
1，滑动窗口
由于排列不会改变字符串中每个字符的个数，所以只有当两个字符串每个字符的个数均相等时，一个字符串才是另一个字符串的排列。
根据这一性质，记 s_1的长度为 n，我们可以遍历 s_2中的每个长度为 nn 的子串，判断子串和 s_1中每个字符的个数是否相等，若相等则说明该子串是 s_1的一个排列。
使用两个数组 cnt 1和 cnt 2，cnt 1统计 s_1中各个字符的个数，cnt 2统计当前遍历的子串中各个字符的个数。
由于需要遍历的子串长度均为 n，我们可以使用一个固定长度为 nn 的滑动窗口来维护 cnt 2：滑动窗口每向右滑动一次，就多统计一次进入窗口的字符，少统计一次离开窗口的字符。然后，判断 cnt 1是否与cnt 2相等，若相等则意味着 s_1的排列之一是 s_2的子串。
class Solution {
public:
bool checkInclusion(string s1, string s2) {
int n = s1.length(), m = s2.length();
if (n > m) {
return false;
}
vector<int> cnt1(26), cnt2(26);
for (int i = 0; i < n; ++i) {
++cnt1[s1[i] - 'a'];
++cnt2[s2[i] - 'a'];
}
if (cnt1 == cnt2) {
return true;
}
for (int i = n; i < m; ++i) {
++cnt2[s2[i] - 'a'];
--cnt2[s2[i - n] - 'a'];
if (cnt1 == cnt2) {
return true;
}
}
return false;
}
};
优化：
注意到每次窗口滑动时，只统计了一进一出两个字符，却比较了整个 cnt 1和 cnt 2数组。
从这个角度出发，我们可以用一个变量 diff 来记录 cnt 1与 cnt 2的不同值的个数，这样判断 cnt 1
和 cnt 2是否相等就转换成了判断 diff 是否为 0.
每次窗口滑动，记一进一出两个字符为 x 和 y.
若 x=y 则对 cnt 2无影响，可以直接跳过。
若 x ！=y，对于字符 x，在修改 cnt 2之前若有 cnt 2[x]=cnt 1[x]，则将 \textit{diff}diff 加一；在修改 cnt 2之后若有 cnt 2[x]=cnt 1[x]，则将 diff 减一。字符 y 同理。
此外，为简化上述逻辑，我们可以只用一个数组cnt，其中 cnt[x]=cnt 2[x]−cnt 1[x]，将 cnt 1[x] 与 cnt 2[x] 的比较替换成 cnt[x] 与 0 的比较。
class Solution {
public:
bool checkInclusion(string s1, string s2) {
int n = s1.length(), m = s2.length();
if (n > m) {
return false;
}
vector<int> cnt(26);
for (int i = 0; i < n; ++i) {
--cnt[s1[i] - 'a'];
++cnt[s2[i] - 'a'];
}
int diff = 0;
for (int c: cnt) {
if (c != 0) {
++diff;
}
}
if (diff == 0) {
return true;
}
for (int i = n; i < m; ++i) {
int x = s2[i] - 'a', y = s2[i - n] - 'a';
if (x == y) {
continue;
}
if (cnt[x] == 0) {
++diff;
}
++cnt[x];
if (cnt[x] == 0) {
--diff;
}
if (cnt[y] == 0) {
++diff;
}
--cnt[y];
if (cnt[y] == 0) {
--diff;
}
if (diff == 0) {
return true;
}
}
return false;
}
};
复杂度分析
时间复杂度：O(n+m+∣Σ∣)，其中 n 是字符串 s_1的长度，m 是字符串 s_2的长度，Σ 是字符集，这道题中的字符集是小写字母，∣Σ∣=26。
空间复杂度：O(∣Σ∣)。
2，双指针
回顾方法一的思路，我们在保证区间长度为 n 的情况下，去考察是否存在一个区间使得 cnt 的值全为 0。
反过来，还可以在保证cnt 的值不为正的情况下，去考察是否存在一个区间，其长度恰好为 n。
初始时，仅统计 s_1中的字符，则 cnt 的值均不为正，且元素值之和为 n。
然后用两个指针 left 和 right 表示考察的区间[left,right]。right 每向右移动一次，就统计一次进入区间的字符 x。为保证 cnt 的值不为正，若此时 cnt[x]>0，则向右移动左指针，减少离开区间的字符的 cnt 值直到 cnt[x]≤0。
注意到[left,right] 的长度每增加 1，cnt 的元素值之和就增加 1。当 [left,right] 的长度恰好为 n 时，就意味着 cnt 的元素值之和为 0。由于cnt 的值不为正，元素值之和为 0 就意味着所有元素均为 0，这样我们就找到了一个目标子串。
class Solution {
public:
bool checkInclusion(string s1, string s2) {
int n = s1.length(), m = s2.length();
if (n > m) {
return false;
}
vector<int> cnt(26);
for (int i = 0; i < n; ++i) {
--cnt[s1[i] - 'a'];
}
int left = 0;
for (int right = 0; right < m; ++right) {
int x = s2[right] - 'a';
++cnt[x];
while (cnt[x] > 0) {
--cnt[s2[left] - 'a'];
++left;
}
if (right - left + 1 == n) {
return true;
}
}
return false;
}
};
复杂度分析
时间复杂度：O(n+m+∣Σ∣)。创建 \textit{cnt}cnt 需要 O(|\Sigma|)O(∣Σ∣) 的时间。遍历 s_1需要 O(n) 的时间。双指针遍历 s_2时，由于 left 和 right 都只会向右移动，故这一部分需要 O(m) 的时间。
空间复杂度：O(∣Σ∣)。