子串
560.和为K的子数组
使用前缀和预处理一下题目给的数组, 然后用二重循环遍历一遍就可以了。
239.滑动窗口最大值
看题面比较容易想到的是用优先级队列来解决, 但是STL中的priority_queue不支持随机删除, 如果要用优先级队列来解决这道题的话比较复杂。这道题的一种正确解法是用单调队列来处理, 单调队列专门用来处理类似滑动窗口的区间最值问题。
接下来来看针对这道题, 单调队列是如何处理元素的入队和出队呢?
- 入队: 从队列的后方入队, 弹出所有比当前元素(即待入队元素)小的元素, 因为这些元素都比当前元素小, 而且入队时间更早, 如果队列中有当前元素, 那么这些较小的元素永远不可能成为答案
- 出队: 从队列的前方出队, 先弹出所有已经在区间外的元素, 然后得到的队头即是当前窗口的最大值
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> res;
deque<int> que; // 出队从前面, 入队从后面
for (int i = 0; i < k; ++i) {
while(!que.empty() && nums[i] > nums[que.back()]) que.pop_back();
que.push_back(i);
}
res.push_back(nums[que.front()]);
for (int i = k; i < nums.size(); ++i) { // 枚举区间右端点
while(!que.empty() && nums[i] > nums[que.back()]) que.pop_back();
que.push_back(i);
while(que.front() <= i-k) {
que.pop_front();
}
res.push_back(nums[que.front()]);
}
return res;
}
};
这类区间最值问题还可以使用ST表或线段树来解决, 不过针对滑动窗口的区间最值问题, 还是单调队列更简便一些。
普通数组
53.最大子数组和
从前往后遍历, 用一个变量来记录和, 如果这个变量记录到的和小于0, 就将它重置为0; 因为它不会给答案带来正面的收益, 算上它之后数组的和只会更小。注意要处理全是负数的数组的情况, 此时答案就为数组中最大的负数。
56. 合并区间
刚开始打算使用使用一个大小为1e4的数组来标记区间, 但是发现这种方法不能处理[1, 4], [5, 7]的例子, 这个例子实际没有产生重叠, 但依旧会在数组中产生一个连续的不为0的区间。正确处理方式是对所有区间按照左端点进行排序, 然后就可以方便的进行合并操作了。
189.轮转数组
使用区间拷贝的库函数, 几行就搞定了。空间复杂度为O(1)的方法可以通过旋转数组来实现。
class Solution {
public:
void rotate(vector<int>& nums, int k) {
k %= nums.size();
vector<int> tmp(nums.rbegin(), nums.rbegin()+k);
copy(nums.begin(), nums.end()-k, nums.begin()+k);
copy(tmp.rbegin(), tmp.rend(), nums.begin());
}
};
238.除自身以外数组的乘积
预处理前缀乘积和后缀乘积即可, 其中一个预处理数组可以使用一个变量来简化, 另一个预处理数组可以使用返回结果数组来代替。
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
vector<int> res(nums.size());
res[0] = 1;
for (int i = 0; i < nums.size()-1; ++i) {
res[i+1] = res[i] * nums[i];
}
int t = 1;
for (int i = nums.size()-1; i >= 0; --i) {
res[i] *= t;
t *= nums[i];
}
return res;
}
};
矩阵
73.矩阵置零
直接说进阶方法，用第1行和第1列来记录第i行/第j列是否需要置零，第1行和第1列是否需要置0可以使用两个标志变量来记录。
54.螺旋矩阵
我采用了一种类似分治的想法，通过一个循环来不断输出数组，在循环的过程中，每输出一整行，剩下需要输出的矩阵的高就减1；同样每输出一整列，剩下需要输出的矩阵的宽就减1，直到剩余矩阵的宽或高变为0时，输出就结束了。通过一个变量来标记当前输出的方向。
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
vector<int> res;
int height = matrix.size();
int width = matrix[0].size();
pair<int, int> pos(0, 0);
/**
* 移动方向
* 1 --- 横向增大
* 2 --- 纵向增大
*
* -1 --- 横向减小
* -2 --- 纵向减小
*/
int dir = 1;
while(height && width) {
if (dir == 1) {
for (int i = 0; i < width; ++i) {
res.push_back(matrix[pos.first][pos.second+i]);
}
--height;
pos.second += width-1;
pos.first += 1;
dir = 2;
} else if (dir == 2) {
for (int i = 0; i < height; ++i) {
res.push_back(matrix[pos.first+i][pos.second]);
}
--width;
pos.first += height-1;
pos.second -= 1;
dir = -1;
} else if (dir == -1) {
for (int i = 0; i < width; ++i) {
res.push_back(matrix[pos.first][pos.second-i]);
}
--height;
pos.second -= width-1;
pos.first -= 1;
dir = -2;
} else if (dir == -2) {
for (int i = 0; i < height; ++i) {
res.push_back(matrix[pos.first-i][pos.second]);
}
--width;
pos.first -= height-1;
pos.second += 1;
dir = 1;
}
}
return res;
}
};
48.旋转图像
矩阵旋转90度，只需要沿对角线翻转矩阵，然后把矩阵逐行逆序即可。
240.搜索二维矩阵
遍历所有列, 二分查找。看了三叶的评论, 发现这个矩阵可以抽象成根节点在矩阵右上角的二叉搜索树, 太妙了。
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) { // 抽象成二叉搜索树
pair<int, int> pos{0, matrix[0].size()-1};
while(true) {
if (target > matrix[pos.first][pos.second]) { // 往右子树查找
if (pos.first == matrix.size()) return false;
++pos.first;
} else if (target < matrix[pos.first][pos.second]) {
if (pos.second == 0) return false;
--pos.second;
} else {
return true;
}
}
return false;
}
};
链表
160.相交链表
可以知道, 如果两个链表相交, 那么从链表的末尾到相交节点的距离一定是相等的, 我们在遍历两个链表的过程中, 可以先将指针移动到距离链表结尾距离相等的位置, 然后同时移动两个指针, 移动过程中查看两个指针是否指向了同一个节点。
206. 翻转链表
头插法即可。这里学习一下如何使用递归来完成翻转, 这里的递归和以前用到的递归形式不太一样, 不太好理解
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if (!head || !head->next) return head;
ListNode* p = head;
ListNode* newHead = reverseList(head->next); // (1)假设head后的所有节点都完成了翻转
head->next->next = head; // (2)翻转后head的下一个节点变成了head前面紧邻的节点
head->next = nullptr; // (3)head->next置空
return newHead; // 返回翻转后的新头节点
}
};
我们现在取一个中间状态来讲解一下，假设现在递归调用到了处理节点2的情况，执行完(1)后链表的情况是这样的
执行完(2)之后链表情况是这样的
执行完(3)之后是这样的
234.回文链表
判断回文串的方式就是找到中间节点, 使用两个指针分别向两边移动, 依次比较即可, 难点主要在链表不能简单的找到它的前驱节点, 我们可以利用递归函数的性质来比较
class Solution {
private:
ListNode* p;
int pos;
public:
bool isPalindrome(ListNode* head) {
ListNode* slow = head, *fast = head;
pos = 0;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
++pos;
}
if (fast) p = slow->next;
else p = slow;
return cmp(head, 0);
}
bool cmp(ListNode* head, int cnt) {
if (cnt < pos) {
if (cmp(head->next, cnt+1)) {
if (head->val == p->val) {
p = p->next;
return true;
} else {
return false;
}
} else {
return false;
}
}
return true;
}
};
