目录
一、水果成篮
1.题目链接：904.水果成篮
2.题目描述：
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组
fruits表示，其中fruits[i]是第i棵树上的水果 种类 。你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
- 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
- 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
- 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组
fruits，返回你可以收集的水果的 最大 数目。示例 1：
输入：fruits = [1,2,1] 输出：3 解释：可以采摘全部 3 棵树。示例 2：
输入：fruits = [0,1,2,2] 输出：3 解释：可以采摘 [1,2,2] 这三棵树。 如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。示例 3：
输入：fruits = [1,2,3,2,2] 输出：4 解释：可以采摘 [2,3,2,2] 这四棵树。 如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。示例 4：
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4] 输出：5 解释：可以采摘 [1,2,1,1,2] 这五棵树。
3.解法（滑动窗口）
🍁算法思路：
研究的对象是一段连续的区间，可以使用「滑动窗口」思想来解决问题。
让滑动窗口满足：窗口内水果的种类只有两种。
做法：右端水果进入窗口的时候，用哈希表统计这个水果的频次。这个水果进来后，判断哈希表的大小：
- 如果大小超过 2：说明窗口内水果种类超过了两种。那么就从左侧开始依次将水果划出窗口，直到哈希表的大小小于等于 2，然后更新结果；
- 如果没有超过 2，说明当前窗口内水果的种类不超过两种，直接更新结果 ret。
🍁算法流程：
a. 初始化哈希表 hash 来统计窗口内水果的种类和数量；
b. 初始化变量：左右指针 left = 0，right = 0，记录结果的变量 ret = 0；
c. 当 right 小于数组大小的时候，一直执行下列循环：
1.将当前水果放入哈希表中；
2.判断当前水果进来后，哈希表的大小：
• 如果超过 2：
- 将左侧元素滑出窗口，并且在哈希表中将该元素的频次减一；
- 如果这个元素的频次减一之后变成了 0，就把该元素从哈希表中删除；
- 重复上述两个过程，直到哈希表中的大小不超过 2；
3.更新结果 ret；
4. right++，让下一个元素进⼊窗口；
d. 循环结束后，ret 存的就是最终结果。
🍁算法代码1（使用容器）：
class Solution
{
public:
int totalFruit(vector<int>& fruits)
{
unordered_map<int, int> hash; // 统计窗口内出现了多少种⽔果
int ret = 0;
for (int left = 0, right = 0; right < fruits.size(); right++)
{
hash[fruits[right]]++; // 进窗口
while (hash.size() > 2) // 判断
{
// 出窗口
hash[fruits[left]]--;
if (hash[fruits[left]] == 0)
hash.erase(fruits[left]);
left++;
}
ret = max(ret, right - left + 1);
}
return ret;
}
};🍁算法代码2（用数组模拟哈希表）：
class Solution
{
public:
int totalFruit(vector<int>& fruits)
{
// 统计窗口内出现了多少种水果
int hash[100001] = {0};
int ret = 0;
for(int left = 0, right = 0, kinds = 0; right < fruits.size(); right++)
{
// 维护水果的种类
if(hash[fruits[right]] == 0) kinds++;
hash[fruits[right]]++;// 进窗口
while(kinds > 2)// 判断
{
hash[fruits[left]]--;// 出窗口
if(hash[fruits[left]] == 0) kinds--;
left++;
}
ret = max(ret, right - left + 1);
}
return ret;
}
};二、找到字符串中所有字母异位词
1.题目链接：438.找到字符串中所有字母异位词
2.题目描述：
给定两个字符串
s和p，找到s中所有p的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
示例 1:
输入: s = "cbaebabacd", p = "abc" 输出: [0,6] 解释: 起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。 起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。示例 2:
输入: s = "abab", p = "ab" 输出: [0,1,2] 解释: 起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。 起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。 起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
3.解法（滑动窗口 + 哈希表）
🍂算法思路：
因为字符串 p 的异位词的长度一定与字符串 p 的长度相同，所以我们可以在字符串 s 中构造⼀个长度为与字符串 p 的长度相同的滑动窗口，并在滑动中维护窗口中每种字母的数量；
- 当窗口中每种字母的数量与字符串 p 中每种字母的数量相同时，则说明当前窗⼝为字符串 p的异位词；
- 因此可以用两个大小为 26 的数组来模拟哈希表，一个来保存 s 中的子串每个字符出现的个数，另一个来保存 p 中每一个字符出现的个数。这样就能判断两个串是否是异位词。
🍂算法代码：
class Solution
{
public:
vector<int> findAnagrams(string s, string p)
{
vector<int> ret;
int hash1[26] = { 0 };// 统计字符串p中每个字符出现的个数
for(auto ch : p) hash1[ch - 'a']++;
int hash2[26] = { 0 };// 统计窗口里边每个字符出现的个数
int m = p.size();
for(int left = 0, right = 0, count = 0; right < s.size(); right++)
{
char in = s[right];
hash2[in - 'a']++;// 进窗口
if(hash2[in - 'a'] <= hash1[in - 'a']) count++;// 维护count
if(right - left + 1 > m)// 判断
{
char out = s[left++];
if(hash2[out - 'a'] <= hash1[out - 'a']) count--;// 维护count
hash2[out - 'a']--;// 出窗口
}
if(count == m) ret.push_back(left);// 更新结果
}
return ret;
}
}; 三、串联所有单词的子串
1.题目链接：30.串联所有单词的子串
2.题目描述：
给定一个字符串
s和一个字符串数组words。words中所有字符串 长度相同。
s中的 串联子串 是指一个包含words中所有字符串以任意顺序排列连接起来的子串。
- 例如，如果
words = ["ab","cd","ef"]， 那么"abcdef"，"abefcd"，"cdabef"，"cdefab"，"efabcd"， 和"efcdab"都是串联子串。"acdbef"不是串联子串，因为他不是任何words排列的连接。返回所有串联子串在
s中的开始索引。你可以以 任意顺序 返回答案。示例 1：
输入：s = "barfoothefoobarman", words = ["foo","bar"] 输出：[0,9] 解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。 子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。 子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。 输出顺序无关紧要。返回 [9,0] 也是可以的。示例 2：
输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"] 输出：[] 解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。 s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。 所以我们返回一个空数组。示例 3：
输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"] 输出：[6,9,12] 解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。 子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。 子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。 子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
3.解法（滑动窗口 + 哈希表）
🍇算法思路：
如果我们把每一个单词看成⼀个⼀个字母，问题就变成了找到「字符串中所有的字母异位词」。无非就是之前处理的对象是⼀个⼀个的字符，我们这里处理的对象是⼀个⼀个的单词。
🍇算法代码：
class Solution
{
public:
vector<int> findSubstring(string s, vector<string>& words)
{
vector<int> ret;
unordered_map<string, int> hash1;// 保存words里面所有单词出现的频次
for(auto& s : words) hash1[s]++;
int len = words[0].size(), m = words.size();
for(int i = 0; i < len; i++)// 总共执行len次
{
unordered_map<string, int> hash2;// 维护窗口内单词的频次
for(int left = i, right = i, count = 0; right + len <= s.size(); right += len)
{
// 进窗口 + 维护窗口
string in = s.substr(right, len);
hash2[in]++;
if(hash1.count(in) && hash2[in] <= hash1[in]) count++;
// 判断
if(right - left + 1 > len * m)
{
// 出窗口 + 维护count
string out = s.substr(left, len);
if(hash1.count(out) && hash2[out] <= hash1[out]) count--;
hash2[out]--;
left += len;
}
if(count == m) ret.push_back(left);
}
}
return ret;
}
};四、最小覆盖子串
1.题目链接：76.最小覆盖子串
2.题目描述：
给你一个字符串
s、一个字符串t。返回s中涵盖t所有字符的最小子串。如果s中不存在涵盖t所有字符的子串，则返回空字符串""。注意：
- 对于
t中重复字符，我们寻找的子字符串中该字符数量必须不少于t中该字符数量。- 如果
s中存在这样的子串，我们保证它是唯一的答案。示例 1：
输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC" 解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。示例 2：
输入：s = "a", t = "a" 输出："a" 解释：整个字符串 s 是最小覆盖子串。示例 3:
输入: s = "a", t = "aa" 输出: "" 解释: t 中两个字符 'a' 均应包含在 s 的子串中， 因此没有符合条件的子字符串，返回空字符串。
3.解法（滑动窗口 + 哈希表）
🍒算法思路：
研究对象是连续的区间，因此可以尝试使用滑动窗口的思想来解决。
如何判断当前窗口内的所有字符是符合要求的呢？
- 我们可以使用两个哈希表，其中一个将目标串的信息统计起来，另一个哈希表动态的维护窗口内字符串的信息。
- 当动态哈希表中包含⽬标串中所有的字符，并且对应的个数都不小于目标串的哈希表中各个字符的个数，那么当前的窗口就是⼀种可行的方案。
🍒算法流程：
a. 定义两个全局的哈希表： 1 号哈希表 hash1 用来记录子串的信息， 2 号哈希表 hash2用来记录目标串 t 的信息；
b. 实现⼀个接口函数，判断当前窗⼝是否满足要求：
i. 遍历两个哈希表中对应位置的元素：
- 如果 t 中某个字符的数量大于窗⼝中字符的数量，也就是 2 号哈希表某个位置大于1 号哈希表。说明不匹配，返回 false ；
- 如果全都匹配，返回 true 。
主函数中：
a. 先将 t 的信息放⼊ 2 号哈希表中；
b. 初始化⼀些变量：左右指针： left = 0，right = 0 ；目标子串的长度： len = INT_MAX ；目标子串的起始位置： retleft ；（通过目标子串的起始位置和长度，我们就能找到结果）。
c. 当 right 小于字符串 s 的长度时，一直下列循环：
i. 将当前遍历到的元素扔进 1 号哈希表中；
ii. 检测当前窗口是否满足条件：
• 如果满足条件：
- 判断当前窗⼝是否变小。如果变小：更新长度 len ，以及字符串的起始位置retleft ；
- 判断完毕后，将左侧元素滑出窗口，顺便更新 1 号哈希表；
- 重复上面两个过程，直到窗口不满足条件；
iii. right++ ，遍历下一个元素；
d. 判断 len 的长度是否等于 INT_MAX ：
i. 如果相等，说明没有匹配，返回空串；
ii. 如果不想等，说明匹配，返回 s 中从 retleft 位置往后 len 长度的字符串。
🍒算法代码：
class Solution {
public:
string minWindow(string s, string t) {
int hash1[128] = {0};// 统计字符串t中每一个字符的频次
int kinds = 0;// 统计有效字符有多少种
for(auto ch : t)
if(hash1[ch]++ == 0) kinds++;
int hash2[128] = {0};// 统计窗口内每个字符的频次
int minlen = INT_MAX, begin = -1;
for(int left = 0, right = 0, count = 0; right < s.size(); right++)
{
char in = s[right];
if(++hash2[in] == hash1[in]) count++;// 进窗口 + 维护count
while(count == kinds)// 判断条件
{
if(right - left + 1 < minlen)// 更新结果
{
minlen = right - left + 1;
begin = left;
}
char out = s[left++];
if(hash2[out]-- == hash1[out]) count--;// 出窗口 + 维护count
}
}
if(begin == -1) return "";
else return s.substr(begin, minlen);
}
};
329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
