目录
1.接雨水
2.合井区间
3.找到字符串中所有字母异位词
4.滑动窗口最大值
5.最小覆盖子串
1.接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
代码如下所示：
class Solution {
public:
int trap(vector<int>& height) {
int n = height.size();
if (n == 0) return 0;
int left = 0, right = n - 1;
int left_max = 0, right_max = 0;
int water = 0;
while (left < right) {
if (height[left] < height[right]) {
if (height[left] >= left_max) {
left_max = height[left]; // 更新左侧最大高度
} else {
water += left_max - height[left]; // 累加雨水
}
++left; // 左指针右移
} else {
if (height[right] >= right_max) {
right_max = height[right]; // 更新右侧最大高度
} else {
water += right_max - height[right]; // 累加雨水
}
--right; // 右指针左移
}
}
return water;
}
};利用两个指针分别从数组的两端向中间遍历。
同时维护两个变量：
left_max：从左侧当前最大高度。
right_max：从右侧当前最大高度。
计算能接的雨水：
如果 height[left] 小于等于 height[right]，则 left 所在位置的最大雨水由 left_max - height[left] 决定，更新左指针。
如果 height[right] 小于 height[left]，则 right 所在位置的最大雨水由 right_max - height[right] 决定，更新右指针。
继续移动指针，直到 left == right。
2.合井区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
// 按区间的起点进行排序
sort(intervals.begin(), intervals.end());
vector<vector<int>> merged;
for (const auto& interval : intervals) {
// 如果结果数组为空，或者当前区间与上一个区间不重叠，直接添加
if (merged.empty() || merged.back()[1] < interval[0]) {
merged.push_back(interval);
} else {
// 如果当前区间与上一个区间重叠，合并它们
merged.back()[1] = max(merged.back()[1], interval[1]);
}
}
return merged;
}
};将区间集合中所有重叠的区间合并成不重叠的区间集合。首先，通过对区间集合按起点升序排序，确保后续处理的区间是按顺序排列的；接着，使用一个结果数组 merged 存储最终的非重叠区间。遍历排序后的区间集合时，如果当前区间与结果数组最后一个区间不重叠，则直接将其加入结果数组；如果重叠，则通过更新终点为两者的较大值来合并区间。这种方法充分利用排序和遍历的性质，以线性方式逐步合并区间，最终返回一个不重叠的区间集合。
3.找到字符串中所有字母异位词
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
字母异位词，字母异位词是通过重新排列不同单词或短语的字母而形成的单词或短语，并使用所有原字母一次。
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
vector<int> result;
if (s.size() < p.size()) return result;
// 记录 p 的字符频率
vector<int> pCount(26, 0), sCount(26, 0);
for (char c : p) {
pCount[c - 'a']++;
}
// 初始化 s 中的滑动窗口
for (int i = 0; i < p.size(); ++i) {
sCount[s[i] - 'a']++;
}
// 检查初始窗口是否匹配
if (sCount == pCount) {
result.push_back(0);
}
// 滑动窗口遍历 s
for (int i = p.size(); i < s.size(); ++i) {
// 添加右侧字符
sCount[s[i] - 'a']++;
// 移除左侧字符
sCount[s[i - p.size()] - 'a']--;
// 检查当前窗口是否匹配
if (sCount == pCount) {
result.push_back(i - p.size() + 1);
}
}
return result;
}
};使用一个固定大小的窗口遍历字符串 s。
在每一步中，检查窗口内的字符计数是否与字符串 p 的字符计数匹配。
如果匹配，则记录当前窗口的起始索引。
使用两个计数器来高效地更新滑动窗口，避免重复计算。
字符计数：pCount 和 sCount 用于存储 p 和当前窗口的字符频率。每个频率数组大小为 26（对应字母 a-z）。
初始窗口设置：初始化 sCount 为 s 中前 p.size() 个字符的频率。
滑动窗口更新：
每次窗口向右滑动一个字符。
添加新字符到窗口中，同时移除窗口最左边的字符。窗口匹配检查：每次更新窗口后检查 sCount 是否等于 pCount，相等时记录窗口的起始索引。
4.滑动窗口最大值
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回 滑动窗口中的最大值 。
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> result;
deque<int> dq; // 双端队列，用来存储窗口中元素的索引
for (int i = 0; i < nums.size(); ++i) {
// 移除不在窗口范围内的元素
if (!dq.empty() && dq.front() < i - k + 1) {
dq.pop_front();
}
// 移除所有小于当前元素的值，它们不可能成为窗口的最大值
while (!dq.empty() && nums[dq.back()] < nums[i]) {
dq.pop_back();
}
// 将当前元素的索引加入队列
dq.push_back(i);
// 窗口形成后（即 i >= k - 1），记录窗口的最大值
if (i >= k - 1) {
result.push_back(nums[dq.front()]);
}
}
return result;
}
};双端队列维护窗口最大值：
双端队列存储的是元素的索引，而不是值。
保证队列中索引对应的值是递减的，从而队列头部始终是窗口内的最大值。
窗口的更新：
移除队列中不在当前窗口范围内的元素。
移除队列中所有小于当前值的元素，因为它们不可能成为当前窗口的最大值。
记录最大值：
每次移动窗口时，将队列头部的值（即当前窗口的最大值）加入结果。
双端队列的性质：
队列中的元素从头到尾递减。
队列头部始终是当前窗口的最大值。
滑动窗口逻辑：
当窗口左边界超出队列中最左边的索引时，移除队列头部。
插入新元素之前，移除队列中所有小于当前值的元素。
结果记录：当窗口的右边界到达 k−1k - 1k−1 或之后时，窗口形成，记录最大值。
5.最小覆盖子串
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。
class Solution {
public:
string minWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
int left = 0, right = 0; // 滑动窗口的左右指针
int valid = 0; // 当前窗口中满足要求的字符数
int start = 0, minLen = INT_MAX; // 最小子串的起始位置和长度
while (right < s.size()) {
char c = s[right]; // 即将移入窗口的字符
right++; // 扩大窗口
// 如果当前字符是目标字符之一，则更新窗口内的数据
if (need.count(c)) {
window[c]++;
if (window[c] == need[c]) valid++;
}
// 判断是否需要收缩窗口
while (valid == need.size()) {
// 更新最小子串
if (right - left < minLen) {
start = left;
minLen = right - left;
}
char d = s[left]; // 即将移出窗口的字符
left++; // 缩小窗口
// 更新窗口内的数据
if (need.count(d)) {
if (window[d] == need[d]) valid--;
window[d]--;
}
}
}
// 如果找到了符合条件的子串，返回它；否则返回空字符串
return minLen == INT_MAX ? "" : s.substr(start, minLen);
}
};使用两个指针表示滑动窗口的起始和结束位置。
用一个哈希表（need）记录字符串 t 中每个字符的频率，用另一个哈希表（window）记录当前窗口中每个字符的频率。
遍历字符串 s，调整窗口的大小：
当窗口中的字符已满足 t 的要求时，尝试收缩窗口。
每次收缩时检查窗口长度，并更新最小长度和起始位置。如果遍历完成后没有找到符合条件的子串，返回空字符串。
