写在前面：此篇博客是以[双指针总结]博客为基础的针对性训练，题源是codetop标签双指针+近一年，频率由高到低
- 1.无重复字符的最长子串
- 2.三数之和
- 3.环形链表
- 4.合并两个有序数组
- 5.接雨水
- 6.环形链表II
- 7.删除链表的倒数第N个节点
- 8.训练计划II
- 9.最小覆盖子串
- 10.回文链表
- 11.长度最小的子数组
- 12.移动零
- 13.盛水最多的容器
- 14.旋转链表
- 15.最接近的三数之和
- 16.删除有序数组中的重复项
- 17. 返回倒数第k个节点的值
- 18. 四数之和
- 19.验证回文串
- 20.字符串的排列
- 21.找出字符串中第一个匹配的下标
- 22.最大连续1的个数II
- 23.数组中的山脉
- 24.移除元素
- 25.两个数组的交集II
- 26.有序数组的平方
- 27.删除有序数组中的重复项II
- 28.寻找重复数
- 29 .水果成篮
- 30.和为k的子数组
- 31.统计[优美子数组]
- 32.区间列表的交集
- 33.将x减到0的最小操作
- 34.替换子串得到平衡字符串
- 35.划分字母区间
- 36.分隔链表
不二刷三刷就是没刷过!!不二刷三刷就是没刷过!!不二刷三刷就是没刷过!!重要的事情说三遍!!!
1.无重复字符的最长子串
之前学习双指针的总结在这里，传送门->双指针总结
在传送门里有一个题是无重复数字的最长子串
是差不多的，简单哒，没事哒
class Solution {
public:
int lengthOfLongestSubstring(string s) {
unordered_map<char, int> a;//map来记录s某个字符出现多少次
int j = 0;//双指针维护的数组是[j，i]
int r = 0;//r是最大长度，不断更新
for(int i = 0; i < s.size(); i ++){//i是维护数组的右边界
a[s[i]] ++;//记录每个s[i]出现的次数
while(a[s[i]] > 1){//一旦重复出现了，那么重复的一定是s[i],因为[j， i-1]是维护好了的
-- a[s[j ++]];//一遍让j往前推，一遍减掉不在维护数组[j，i]内的字符次数
}
r = max(r, i - j + 1);
}
return r;
}
};
2.三数之和
还是上一题传送门，里面有原题讲解，这里再贴一遍代码
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<vector<int>> res;
for(int i = 0; i < nums.size(); i ++){
if(i && nums[i] == nums[i - 1]) continue;
for(int j = i + 1, k = nums.size() - 1; j < k; j ++){
if(j > i + 1 && nums[j] == nums[j - 1]) continue;
while(j < k && nums[i] + nums[j] + nums[k] > 0) k --;
if(j < k && nums[i] + nums[j] + nums[k] == 0) res.push_back({nums[i], nums[j], nums[k]});
}
}
return res;
}
};
3.环形链表
很意外的没有一次通过，这一题在传送门里面也有，纯原题
主要是while(fast!=NULL && fast->next != NULL && fast->next->next != NULL)
一开始写成了while(fast!=NULL && fast->next->next != NULL)
不可以跳过fast->next直接判断fast->next->next，如果fast->next == NULL
会触发未定义错误
class Solution {
public:
bool hasCycle(ListNode *head) {
if(head == NULL || head->next == NULL) return false;
ListNode* slow = head;
ListNode* fast = head->next;
while(fast!=NULL && fast->next != NULL && fast->next->next != NULL){
if(slow == fast) return true;
fast = fast->next->next;
slow = slow->next;
}
return false;
}
};
4.合并两个有序数组
两个非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
要求合并到nums1数组内，需要考虑两个边界，oldIndex和p2，如果p2为空了，剩下的nums1根本不用动，可以直接返回，所以这里while语句里面应该是p2>=0！
这里稍微debug了一会，还是得先想清楚再敲
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int oldIndex = m - 1; // 最后一个有效元素的位置
int newIndex = m + n - 1; // 合并后最后一个位置
int p2 = n - 1; // nums2的最后一个元素的位置
while (p2 >= 0) {
if (oldIndex >= 0 && nums1[oldIndex] > nums2[p2]) {
nums1[newIndex--] = nums1[oldIndex--];
} else {
nums1[newIndex--] = nums2[p2--];
}
}
}
};
5.接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
找凹槽，在单调栈的一篇文秒杀整个题型里面也有这个题->传送门
class Solution {
public:
int trap(vector<int>& height) {
stack<int> s;
vector<int> res;
int sum = 0;
for(int i = 0; i < height.size(); i ++){
while(!s.empty() && height[s.top()] < height[i]){
int mid = height[s.top()];
s.pop();
if(!s.empty()){
int h = min(height[s.top()], height[i]) - mid;
int w = i - s.top() - 1;
sum += h * w;
}
}
s.push(i);
}
return sum;
}
};
6.环形链表II
秒杀系列里面的原题
没有秒杀，耻辱的忘记怎么做了，罚自己手写思路
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
if(head == NULL || head->next == NULL) return NULL;
ListNode* slow = head;
ListNode* fast = head;
while(fast!=NULL&& fast->next!=NULL&&fast->next->next!=NULL){
slow = slow->next;
fast = fast->next->next;
if(slow == fast){
ListNode* p2 = slow;
ListNode* p1 = head;
while(p1 != p2){
p1 = p1->next;
p2 = p2->next;
}
return p1;
}
}
return NULL;
}
};
7.删除链表的倒数第N个节点
还是双指针传送门的原题，秒了
但是有个地方当时写题解其实没有太明白
- dummy的必要性，为了同一删除操作，假如链表长度是n，又要删除倒数第n个节点即头结点，加了dummy就不需要单独讨论了
- 为什么i<=n，注意最后的while(fast)这个地方，当fast来到了表尾，还是能进入循环的，fast再走一步是空，slow还能再走，这样正好可以删除，所以必须slow和fast中间空出两个元素！
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummy = new ListNode(0);
dummy->next = head;
ListNode* slow = dummy;
ListNode* fast = dummy;
for(int i = 0; i <= n; i ++){
fast = fast->next;
}
while(fast){
fast = fast->next;
slow = slow->next;
}
ListNode* p = slow->next;
slow->next = slow->next->next;
delete p;
ListNode* newHead = dummy->next;
delete dummy;
return newHead;
}
};
8.训练计划II
这题时间复杂度卡的很松
class Solution {
public:
ListNode* trainingPlan(ListNode* head, int cnt) {
if(!head) return NULL;
int len = 1;//记录链表长度.
ListNode *p = head;
while(p->next)
{
len++;
p = p->next;
}
p = head;
while(len - cnt)
{
p = p->next;
len --;
}
return p;
}
};
9.最小覆盖子串
很意外，为什么出现在双指针的标签下
这题考的滑动窗口
紧急写了篇滑动窗口的秒杀文章->传送门
二刷有个容易没注意到的地方：
缩小窗口的时候必须先判断valid–
再window–
class Solution {
public:
string minWindow(string s, string t) {
unordered_map<char, int> window;
unordered_map<char, int> need;
for(char c : t) need[c]++;
int start = 0;
int len = INT_MAX;
int left = 0;
int right = 0;
int valid = 0;
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 < len){
start = left;
len = right - left;
}
char a = s[left];
left++;
if(need.count(a)){
if(window[a] == need[a]) valid--;
window[a]--;
}
}
}
return len == INT_MAX ? "" : s.substr(start, len);
}
};
10.回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为
回文链表。如果是，返回 true ；否则，返回 false 。
力扣234.
思路不难，但是好多细节需要注意
首先不能用双指针总结找中间的节点的办法，因为那个主要是保证fast能走到底，并且slow是会走到双数链表的中间节点靠右第二个
而这题主要是找中点，并且应该是靠左那个
所以直接->next->next就好，这样的fast不一定走到底，但是也不用管了
找到中点之后，将slow后面的指针指向翻转
最后从两边走到中间去比较
用while(p2)判断是否走完，因为p2指的是更短那根，可以把奇数链表中间多余节点忽略掉
class Solution {
public:
bool isPalindrome(ListNode* head) {
//找中点
ListNode* slow = head;
ListNode* fast = head;
while(fast != NULL && fast->next != NULL && fast->next->next !=NULL){
fast = fast->next->next;
slow = slow->next;
}
//slow在的位置就是中点，奇数的话就是中间的数，偶数的话就是中间两个左边的数
//反转中点右边的链表
ListNode* pre = NULL;
ListNode* cur = slow->next;
while(cur){
ListNode* temp = cur->next;
cur->next = pre;
pre = cur;
cur = temp;
}
slow->next = NULL;
//比较两部分链表，第一条从head开始，第二条从pre开始，这个时候的cur已经是空了
//从两边开始避免了奇数中间那个多余数的比较
//要么一样长，要么第二条短，所以while(p2)
ListNode* p1 = head;
ListNode* p2 = pre;
while(p2){
if(p2->val != p1->val) return false;
p2 = p2->next;
p1 = p1->next;
}
return true;
}
};
11.长度最小的子数组
考滑动窗口的
要注意是大于等于不是等于
看错题目一顿调
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int left = 0;
int right = 0;
int sum = 0;
int len = INT_MAX;
while(right < nums.size()){
sum += nums[right];
right++;
while(sum >= target){
len = min(len, right - left);
sum -= nums[left];
left ++;
}
}
return len == INT_MAX ? 0 : len;
}
};
12.移动零
非0元素前移，这和秒杀双指针里面的移除特定元素是一样的
最后别忘了填充
class Solution {
public:
void moveZeroes(vector<int>& nums) {
//非0前移
int slow = 0;
for(int fast = 0; fast < nums.size(); fast ++){
if(nums[fast] != 0){
nums[slow] = nums[fast];
slow++;
}
}
//剩下部分填充0
for(; slow < nums.size(); slow ++) nums[slow] = 0;
}
};
13.盛水最多的容器
双指针秒杀里面的原题
class Solution {
public:
int maxArea(vector<int>& height) {
int left = 0, right = height.size() - 1;
int r = 0;
while(left < right){
r = max(r, min(height[right], height[left]) * (right - left));
if(height[left] < height[right]) left ++;
else right --;
}
return r;
}
};
14.旋转链表
整体思路是，将链表头尾连起来，再在新的表尾处砍断
里面有非常多的小细节，比如 k = k % length;
寻找新的表尾：成环右移k个，说明链表倒数第k个会变成表头，for (int i = 0; i < length - k - 1; i++)可以定位到表头前面一个也就是表尾
class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if (!head || !head->next || k == 0) return head;
// 第一步：计算链表长度并形成环形链表
ListNode* lastNode = head;
int length = 1;
while (lastNode->next) {
lastNode = lastNode->next;
length++;
}
lastNode->next = head; // 形成环形链表
// 第二步：计算实际需要移动的步数
k = k % length;
if (k == 0) {
lastNode->next = NULL; // 恢复链表
return head;
}
// 第三步：找到新的头节点和尾节点
ListNode* newTail = head;
for (int i = 0; i < length - k - 1; i++) {
newTail = newTail->next;
}
ListNode* newHead = newTail->next;
// 断开链表
newTail->next = NULL;
return newHead;
}
};
15.最接近的三数之和
别人写的代码怎么这么优雅┭┮﹏┭┮
重点在于判断最近的，用abs绝对值
if(abs(target - close) < abs(target - closeNum)) closeNum = close
close是当前的三个元素，closeNum是最接近的，初始化为nums[0] + nums[1] + nums[2]
这个return的是和，重复不重复只是降低复杂度，不会改变答案，不用像三数之和一样死扣不重复
class Solution {
public:
int threeSumClosest(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
int closeNum = nums[0] + nums[1] + nums[2];
for(int i = 0; i < nums.size(); i ++){
if(i && nums[i] == nums[i - 1]) continue;
int left = i + 1, right = nums.size() - 1;
while(left < right){
int close = nums[i] + nums[left] + nums[right];
if(abs(target - close) < abs(target - closeNum)) closeNum = close;
if(close > target) right--;
else if(close < target) left++;
else return target;
}
}
return closeNum;
}
};
16.删除有序数组中的重复项
快慢指针，一开始没能灵活应用，还得练
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int slow = 0, fast = 1;
while(fast < nums.size()){
if(nums[slow] == nums[fast]){
fast++;
}else{
slow++;
nums[slow] = nums[fast];
}
}
return slow + 1;
}
};
17. 返回倒数第k个节点的值
假如链表长度是k，返回倒数第k个的情况要留意处理
这题题目给的k一定是合理的！
class Solution {
public:
int kthToLast(ListNode* head, int k) {
ListNode* slow = head;
ListNode* fast = head;
// fast 指针先前进 k 步
for (int i = 0; i < k; i++) {
fast = fast->next;
}
// 同时前进 slow 和 fast，直到 fast 到达链表末尾
while (fast != nullptr) {
fast = fast->next;
slow = slow->next;
}
// 此时 slow 所指向的即为倒数第 k 个节点
return slow->val;
}
};
18. 四数之和
双指针秒杀原题
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
vector<vector<int>> res;
for(int i = 0; i < nums.size(); i ++){
if(i && nums[i] == nums[i - 1]) continue;
for(int j = i + 1; j < nums.size(); j ++){
if(j > i + 1 && nums[j] == nums[j - 1]) continue;
for(int k = j + 1, u = nums.size() - 1; k < u; k ++){//双指针
if(k > j + 1 && nums[k] == nums[k - 1]) continue;
while(k < u && (long long)nums[i] + nums[j] + nums[k] + nums[u] > target) u--;
if(k < u && (long long)nums[i] + nums[j] + nums[k] + nums[u] == target) res.push_back({nums[i], nums[j], nums[k], nums[u]});
}
}
}
return res;
}
};
19.验证回文串
先把所有字符转化成小写，并过滤掉空格和标点这类字符。然后对剩下的字符执行双指针中的两端向中心的双指针算法即可。
新学到的库函数：
- isalnum( c )：isalnum 检查字符c是不是字母或者数字，如果是的话，返回true，不是的话返回false
- tolower( c )：tolower 将字符 c 转换为小写字母。如果 c 本身是小写字母或非字母字符，返回值将与 c 相同。
class Solution {
public:
bool isPalindrome(string s) {
string sb;
for(int i = 0; i < s.size(); i ++){
char c = s[i];
if(isalnum(c)){
sb += tolower(c);
}
}
//双指针两头往中间验证
s = sb;
int left = 0, right = sb.size() - 1;
while(left < right){
if(sb[left] != sb[right]) return false;
left++;
right--;
}
return true;
}
};
20.字符串的排列
在滑动窗口总结文章里面讲解过了
秒啦
class Solution {
public:
bool checkInclusion(string s1, string s2) {
unordered_map<char, int> window, need;
for(char c : s1) need[c] ++;
int left = 0, right = 0;
int valid = 0;
while(right < s2.size()){
char c = s2[right];
right++;
if(need.count(c)){
window[c]++;
if(need[c] == window[c]) valid++;
}
while(right - left > s1.size()){
char d = s2[left];
left ++;
if(need.count(d)){
if(need[d] == window[d]) valid--;
window[d]--;
}
}
if(need.size() == valid && right - left == s1.size()){
return true;
}
}
return false;
}
};
21.找出字符串中第一个匹配的下标
拿到手的第一想法就是，滑动窗口，输出left
但是这个要求顺序完全一样，不能是排列或者组合
查了一下KMP是专门弄这种的，学习新算法了
(我只是来做双指针的…)这篇文章是个纯刷题记录，不贴详细讲解，最多记录大致思路，需要讲解去秒杀直接部分->传送门
class Solution {
public:
int strStr(string haystack, string needle) {
int n = haystack.size();
int m = needle.size();
vector<int> ne(m, -1);
// 建next数组
for(int i = 1, j = -1; i < m; i ++){
while(j != -1 && needle[i] != needle[j + 1]) j = ne[j];
if(needle[i] == needle[j + 1]) j ++;
ne[i] = j;
}
// 匹配
for(int i = 0, j = -1; i < n; i ++){
while(j != -1 && haystack[i] != needle[j + 1]) j = ne[j];
if(haystack[i] == needle[j + 1]) j ++;
if(j == m - 1){
return i - m + 1;
}
}
return -1;
}
};
22.最大连续1的个数II
不是，家人们，滑动窗口为什么都划到双指针标签下了啊
题：
给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。
eg：
输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
在秒杀系列的滑动窗口秒杀文章里面写过
用滑动窗口做题需要先明白3个问题
- 什么时候扩大窗口？更改什么数据？
- 什么时候缩小窗口？更改什么数据？
- 什么时候得到答案？
针对123的答案：
- 当可替换次数k>=0的时候扩大窗口，更改窗口里面1的个数，让窗口里面都是1，等于0的时候也扩，万一窗口外面不需要改呢。
- 当可替换次数k<0的时候缩小窗口，可替换次数++，以便继续扩大
- k>=0的时候，窗口内部都是1，len更新
class Solution {
public:
int longestOnes(vector<int>& nums, int k) {
int left = 0, right = 0;
int windowOneCount = 0;
int res = 0;
while(right < nums.size()){
//right是0也++,是1就windowOneCount++,自身也++
if(nums[right] == 1){
windowOneCount ++;
}
right ++;
//窗口里面0的个数超过了k,就开始缩小窗口
while(right - left - windowOneCount > k){
if(nums[left] == 1) windowOneCount --;
left ++;
}
res = max(res, right - left);
}
return res;
}
};
23.数组中的山脉
先找到可能得山顶，再双指针两边扩展，记录res
留意l，r，i的边界
class Solution {
public:
int longestMountain(vector<int>& arr) {
int l = 0, r = 0, res = 0;
for(int i = 1; i < arr.size() - 1; i ++){
if(arr[i] > arr[i - 1] && arr[i] > arr[i + 1]){
l = i - 1;
r = i + 1;
while(l > 0 && arr[l] > arr[l - 1]) l --;
while(r < arr.size() - 1 && arr[r] > arr[r + 1]) r ++;
res = max(res, r - l + 1);
}
}
return res;
}
};
24.移除元素
移除val，返回新数组的长度
双指针里也有这题，秒啦
class Solution {
public int removeElement(int[] nums, int val) {
int i = 0;
for (int n : nums)
if (n != val) {
nums[i] = n;
i++;
}
return i;
}
}
25.两个数组的交集II
给nums1和nums2，以数组的形式返回两数组里都存在的数，并且这个数的次数要等于两个数组中这个数出现次数更少的那个
别人的代码是真的优雅
这个代码先记录了nums1中每个元素出现的次数到umap中
再在nums2中for每个元素
如果元素在umap中有记录则将其push进res，并且umap记录数–
假如nums1中才是数字出现少的那个，那么umap[nums1]会先到0，以至于res不了nums2的元素，假如nums2才是数字出现少的那个，那么if(nums2)会先空
太优雅了o(╥﹏╥)o
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int, int> umap;
vector<int> res;
for(int i = 0; i < nums1.size(); i ++) umap[nums1[i]]++;
for(int i = 0; i < nums2.size(); i ++){
if(umap[nums2[i]]){
res.push_back(nums2[i]);
umap[nums2[i]] --;
}
}
return res;
}
};
26.有序数组的平方
给一个非递减的数组，现在需要你将每个元素都平方，然后递增排序，返回nums。注意，需要时间复杂度是O(n)
sort的家伙，以后面试也排人后面！！！！
sort的复杂度是O(nlogn)，所以不能用sort，只能用双指针
这里有个十分关键的点，就是：原本的数组本身就是有序的，是一个非递减的数组，那么即使数组中元素有正有负，绝对值最大的元素肯定是在数组的两端的，即数组平方的最大值是在数组的两端的。
所以我们可以使用两个双指针i,j一个指向起始位置，一个指向数组的末尾。
定义一个新的数组result用于储存新的有序平方后的元素。
class Solution {
public:
//双指针
vector<int> sortedSquares(vector<int>& A) {
int k = A.size() - 1; //指向新数组的末尾，从后往前赋值
vector<int> result(A.size(), 0);
for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
if (A[i] * A[i] < A[j] * A[j]) { //判断条件1：尾部元素更大
result[k--] = A[j] * A[j];
j--;
}
else {
result[k--] = A[i] * A[i]; //判断条件2：头部元素更大
i++;
}
}
return result;
}
};
27.删除有序数组中的重复项II
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
前2个肯定不用删，所以可以跳过，从j = 2开始比
还是太优雅了这代码
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size() <= 2) return nums.size();
int i = 2;
for(int j = 2; j < nums.size(); j ++){
if(nums[j] != nums[i - 2]){
nums[i] = nums[j];
i ++;
}
}
return i;
}
};
28.寻找重复数
不可以用sort也不可以用额外数组
这个要求真的是把我路都堵死了…
数组小技巧：数组也可以看做链表来做
class Solution {
public:
int findDuplicate(vector<int>& nums) {
int fast = 0, slow = 0;
while(true){
fast = nums[nums[fast]];
slow = nums[slow];
if(fast == slow) break;
}
slow = 0;
while(fast != slow){
fast = nums[fast];
slow = nums[slow];
}
return slow;
}
};
29 .水果成篮
fruits数组，fruits[i]代表一种水果，比如fruits[2] = 1，,代表香蕉
现在有fruits.size()棵水果树，每次只能摘一颗树
现在有2个篮子，每个篮子装一种水果，问最多能摘多少棵数
fruit = [1,2,1]，有两种水果树，所以能摘三棵，都能摘，篮子装得下
滑动窗口。要注意不需要window.size() == need，也要计算len，因为有while(window.size() > need)在，窗口不是小了就是刚刚好，不可能大，如果fruit的水果树种类本来就不足2个，就可以返回
另外，当缩小窗口，导致其中一个苹果树没了，window应该erase掉。否则还占用一个size
class Solution {
public:
int totalFruit(vector<int>& fruits) {
unordered_map<int, int> window;
int need = 2;
int len = 0;
int left = 0, right = 0;
while(right < fruits.size()){
int c = fruits[right];
right++;
window[c]++;;
while(window.size() > need){
int d = fruits[left];
left++;
window[d]--;
if(window[d] == 0) window.erase(d);
}
len = max(len, right - left);
}
return len;
}
};
30.和为k的子数组
给你一个整数数组nums和一个整数k，请你统计并返回该数组中和为k的子数组个数。子数组是数组中元素的连续非空序列
被骗啦，滑窗酷酷一顿做，结果nums可以有负数
也就是说left++的话窗口和也不一定变小，right++也不一定窗口和变大
滑动窗口失效的时候要用前缀和，前缀和我也写过秒杀系列->传送门
前缀和与子数组的关系是prefix[j] - prefix[i - 1] = k，假设现在遍历到k
先将前缀和prefix[j]存入哈希表，在求prefix[j] - k，看他在不在哈希表，如果在的话，说明存在一个prefix[i - 1]使prefix[j] - prefix[i - 1] = k
- 将当前累加和减去整数k的结果，在哈希表中查找是否存在
- 如果存在该key，证明以数组某一点为起点到当前位置满足题意，res+=val
- 判断当前累加和是否在哈希表中，若存在value+1，不存在则value=1
class Solution {
public:
int subarraySum(vector<int>& nums, int k) {
unordered_map<int ,int> preSumCount = {{0, 1}};
int preSum = 0, count = 0;
for(int num : nums){
preSum += num;
count += preSumCount[preSum - k];
preSumCount[preSum]++;
}
return count;
}
};
31.统计[优美子数组]
看起来又很像滑动窗口，但其实最好别用，因为滑动窗口一般用来解决的是窗口符合某个特定条件的问题，而不是窗口的数量，这种情况一般用哈希表和前缀和，并且这题和30其实很像
我们可以通过记录前缀和出现的次数，来计算有多少个符合条件的子数组
prefix_count[i] = k 表示前缀和有i个奇数的数组有k个
class Solution {
public:
int numberOfSubarrays(vector<int>& nums, int k) {
unordered_map<int, int> preSumNums = {{0, 1}};
int count = 0, curSum = 0;
for(int num : nums){
curSum += (num % 2 == 1 ? 1 : 0);//奇数当1,偶数当0
if(preSumNums.find(curSum - k) != preSumNums.end()) count += preSumNums[curSum - k];
preSumNums[curSum]++;
}
return count;
}
};
32.区间列表的交集
i为first的行，j为second的行
class Solution {
public:
vector<vector<int>> intervalIntersection(vector<vector<int>>& firstList, vector<vector<int>>& secondList) {
int i = 0, j = 0, n = firstList.size(), m = secondList.size();
vector<vector<int>> res;
while(i < n && j < m){
int l = max(firstList[i][0], secondList[j][0]);
int r = min(firstList[i][1], secondList[j][1]);
if(l <= r) res.push_back({l, r});
firstList[i][1] > secondList[j][1] ? j ++ : i ++;
}
return res;
}
};
33.将x减到0的最小操作
有些题目真的就是破烂(艹皿艹 )
这题考滑动窗口，但是考的很隐蔽，题目说只能移除nums最左边和最右边的元素，目标值是x，可以反着来，目标区间是中间的区域，目标值是sum - x
注意，元素一加立刻right++的话，窗口长度是right-left
for的话因为right会晚一步+1，所以窗口长度是right-left+1
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
int sum = 0, temp = 0, res = -1;
for(int num : nums) sum += num;
int target = sum - x;
if(target < 0) return -1;
int left = 0, right = 0;
while(right < nums.size()){
temp += nums[right];
right ++;
while(temp > target) temp -= nums[left++];
if(temp == target) res = max(res, right - left);
}
return res == -1 ? -1 : nums.size() - res;
}
};
34.替换子串得到平衡字符串
还是滑动窗口，不太一样的是，要观察的是窗口外的元素，可以叫他反向滑动(名字我瞎取得。
设m = n/4。
滑动窗口内部是待替换字符串，窗口外是不替换的。
所以窗口外Q,W,E,R的个数都小于等于m，替换窗口内的字母才可能让字符串平衡。
所以right++意味着外面的元素少一个，这个是替换window需要记录的
如果窗口外有字符大于m，说明窗口内无论怎么替换都无法平衡。
用哈希表统计原串的字符个数
固定左边界，移动右边界。
如果剩余部分不替换的字符串中所有字母个数均≤m，则说明可以构造平衡字符串，则用滑窗长度更新最小替换子串长度
然后移动左边界，对子串长度进行缩小。
class Solution {
public:
int balancedString(string s) {
int n = s.size();
int res = INT_MAX;
unordered_map<char, int> a;
for(char c : s) a[c] ++;
int m = n / 4;
if(a['Q'] == m && a['W'] == m && a['E'] == m && a['R'] == m) return 0;
int l = 0, r = 0;
while(r < n){
char d = s[r];
r ++;
a[d] --;
while(a['Q'] <= m && a['W'] <= m && a['E'] <= m && a['R'] <= m){
res = min(res, r - l);
char c = s[l];
a[c] ++;
l ++;
}
}
return res;
}
};
35.划分字母区间
再强调一遍，不二刷三刷的题目就是没刷过
class Solution {
public:
vector<int> partitionLabels(string s) {
// 更新每个字母出现的最远下标
// 区间内更新其中每个字母出现的最远下标，i等于这个下标的时候片段+1
int hash[27] = {0};//hash数组里面是不同字母对应的ascll码的最远下标
for(int i = 0; i < s.size(); i ++){
hash[s[i] - 'a'] = i;
}
vector<int> result;
int left = 0;
int right = 0;
for(int i = 0; i < s.size(); i ++){
right = max(right, hash[s[i] - 'a']);
if(i == right){
result.push_back(right - left + 1);
left = i + 1;
}
}
return result;
}
};
36.分隔链表
双指针总结里面原题
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
ListNode* dummy1 = new ListNode(0);
ListNode* p1 = dummy1;
ListNode* dummy2 = new ListNode(0);
ListNode* p2 = dummy2;
ListNode* cur = head;
while(cur){
if(cur->val < x){
p1->next = cur;
p1 = p1->next;
}else{
p2->next = cur;
p2 = p2->next;
}
ListNode* temp = cur;
cur = cur->next;
temp->next = NULL;
}
p1->next = dummy2->next;
delete dummy2;
return dummy1->next;
}
};
持续更新ing
2024/8/5
![[flink]部署模式](https://i-blog.csdnimg.cn/direct/de368a824de2490cb5d56e8c9446eb77.png)
