求模运算的性质：
(a * b) % k = (a % k)(b % k) % k;
框架总结:
回溯算法
result = []
def backtrack(路径， 选择列表):
if 满足条件列表：
result.add(路径)
return
for选择 in 选择列表：
做选择
backtrack(路径， 选择列表)
撤销选择
二分查找算法
int binarySearch(int[] nums, int target) {
int left = 0, right = ...;
while (...) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
...
} else if (nums[mid] < target) {
left = ...
} else if (nums[mid] > target) {
right = ...
}
}
return ...;
滑动窗口算法框架
void slidingWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c: t) {
need[c]++;
}
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
char c = s[right++];
... // 进行窗口更新的操作
// debug的位置
// 判断左窗口是否要收缩。
while (window needs shrink) {
char d = s[left++];
...// 进行窗口内数据的一系列更新
}
}
}
BFS框架
int BFS(Node start, Node target) {
queue<Node> q;
set<None> visited;
q.push(start);
visited.insert(start);
int step = 0;
while (!q.empty()) {
int sz = q.size();
for (int i = 0; i < sz; ++i) {
Node cur = q.front();
if (cur == target) {
return step;
}
// 将cur的相邻节点加入队列
for (Node x : cur.adj()) {
if (x not in visited) {
q.push(x);
visited.insert(x);
}
}
}
++step;
}
}
动态规划的基本框架
for 状态1 in 状态1的所有状态：
for 状态2 in 状态2的所有状态：
for ...
dp[状态1][状态2][...] = 择优(选择1, 选择2, ...)
动态规划子序列问题模板
一维的dp数组：
int n = array.size();
int[] dp = new int[n];
for (int i = 1; i < n; ++i) {
for (int j = 1; j < i; ++j) {
dp[i] = 最值(dp[i], dp[j] + ...)
}
}
// dp[i]的定义：针对单个字符串/数组，如最长递增子序列。
// 在子数组arr[0...i]中，我们要求的子序列(例如：最长递增子序列)的长度是dp[i].
二维的dp数组：
int n = array.size();
int[] dp = new int[n][n];
for (int i = 1; i < n; ++i) {
for (int j = 1; j < n; ++j) {
if (arr[i] == arr[j]) {
dp[i][j] = dp[i][j] + ...;
} else {
dp[i][j] = 最值(...);
}
}
}
//dp[i][j]的含义：
// case1:涉及两个字符串/数组时:
// 在子数字arr1[0...i]和子数组arr2[0...j]中，我们要求的子序列(如最长公共子序列)的长度为dp[i][j];
// case2：只设计一个字符串/数组时：
// 在arr[i...j]中，我们要求的子序列(例如最长回文子序列)的长度为dp[i][j].
贪心算法调度问题（最多开几个会的类似问题）
int intervalSchedule(vector<vector<int>> intvs) {
if (intvs.empty()) {
return 0;
}
// 按end升序排序
sotr(intvs.begin(), intvs.end(), [](vector<int> a, vector<int> b) {
return b[1] > a[1];
});
// 至少有一个区间不相交
int count = 1;
// 排序后，第一个区间就是x
int x_end = intvs[0][1];
for (auto interval : intvs) {
int start = interval[0];
if (start >= x_end) {
// 找到下一个选择区间
++count;
x_end = interval[1];
}
}
return count;
}
股票买卖问题
class Solution {
public:
int maxProfit(int k, vector<int>& prices) {
// 备注：买进来和卖出去合起来算交易一次。
if (k < 1 || prices.size() < 2) {
return 0;
}
// dp[i][j][0]:第i天，经过最多j次交易，手里未持有股票的利润。
// dp[i][j][1]:第i天，经过最多j次交易，手里持有股票的利润。
vector<vector<pair<int, int>>> dp(prices.size(),
vector<pair<int, int>>(k + 1, make_pair(0, 0)));
for (int i = 1; i <= k; ++i) {
dp[0][i].second = -prices[0];
}
for (int i = 1; i < prices.size(); ++i) {
for (int j = 1; j <= k; ++j) {
dp[i][j].first = max(dp[i - 1][j].first,
dp[i - 1][j].second + prices[i]);
dp[i][j].second = max(dp[i - 1][j].second,
dp[i - 1][j - 1].first - prices[i]);
}
}
return dp[prices.size() - 1][k].first;
}
};
LRU
class Node {
public:
int key, val;
Node* next, prev;
Node(int k, int v) {
key = k;
val = v;
}
};
// 构建双向链表
class DoubleList {
public:
// 在链表头部添加节点x
void addFirst(Node *x);
// 删除链表中的x节点
void remove(Node *x);
// 删除链表中最后一个节点,并返回
Node* removeLast();
// 返回链表长度
int size();
};
class LRUCache {
private:
Map<int, Node*> my_map; // 映射表
DoubleList cache; // 双向链表
int cap; // 最大容量
public:
LRUCache(int capacity) {
this.cap = capacity;
}
int get(int key) {
if (my_map.count(key) == 0) {
return -1;
}
int val = my_may.get(key)->val;
// 利用put方法把该数据提前
put(key, val);
return val;
}
void put(int key, int val) {
// 先把新节点做出了
Node* x = new Node(key, val);
if (my_map.count(key)) {
// 删除旧的节点，新的插到头部
cache.remove(my_map.get(key));
cache.addFirst(x);
// 更新map中的数据
map.put(key, x);
} else {
if (cap == cache.size()) {
// 删链表最后一个数据
Node* last = cache.removeLast();
my_map.remove(last->key);
}
// 添加到头部
cache.addFirst(x);
map.put(key, x);
}
}
};
二叉数算法的框架
// 通用框架
void traverse(TreeNode* root) {
// root需要做什么，在这里做
// 其他不用root操心，抛给框架
traverse(root->left);
traverse(root->right);
}
// BST(二叉搜索树)的框架
void BST(TreeNode* root, int target) {
if (root->val == target) {
// 找到目标，做点什么
}
if (root->val < target) {
BST(root->right, target);
} else {
BST(root->right, target);
}
}
单调栈问题（下一个更大的数）
vector<int> nextGreaterElement(vector<int> &nums) {
vector<int> ans(nums.size()); // 存放答案的数组
stack<int> s;
for (int i = nums.size() - 1; i >= 0; --i) {
while (!s.empty() && s.top() <= nums[i]) {
s.pop(); //小的数字弹出，
}
ans[i] = s.empty() ? -1 : s.top(); //这个元素后面第一个比他大的值
s.push(nums[i]); // 进栈
}
return ans;
}
单调队列
class MonotonicQueue {
private:
deque<int> data;
public:
void push(int n) {
while (!data.empty() && data.back() < n) {
data.pop_back();
}
data.push_back(n);
}
int max() {
return data.front();
}
void pop(int n) {
if (!data.empty() && data.front() == n) {
data.pop_front();
}
}
};
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
MonotonicQueue Window;
vector<int> res;
fof (int i = 0; i < nums.size(); ++i) {
if (i < k - 1) {
window.push(nums[i]);
} else {
window.push(nums[i]);
res.push_back(window.max());
window.pop(nums[i - k + 1]);
}
}
return res;
}
twoSum问题
// 利用哈希表优化时间负责度，用空间换取时间。
class TwoSum {
private:
map<int, int> freq;
public:
void add(int number) {
freq.insert(make_pair(number, freq[number]++));
}
bool find(int value) {
for (auto key : freq) {
int other = value - key.first;
// 情况1
if (other == key.first && key.second > 1) {
return true;
}
// 情况2
if (other != key && freq.count(other) > 0) {
return true;
}
}
return false;
}
};
常用的位操作
// 利用或操作和空格将英文字母转化为小写
('a' | ' ') = 'a';
// 利用与操作和下划线将英文字母转换为大写
('b' & '_') = 'B';
// 利用异或操作和空格进行英文字符大小写互换
('d' ^ ' ') = 'D';
// 判断两个数是否异号
int x = -1, y = 2;
bool f = ((x ^ y) < 0); // true
int x = 3, y = 2;
bool f = ((x ^ y) < 0); // false
// 交换两个数
int a = 1, b = 2;
a ^= b;
b ^= a;
a ^= b;
// 现在a = 2, b = 1;
// 加一
int n = 1;
n = -~n; //n = 2;
// 减一
int n = 2;
n = ~-n; // n = 1;
// 消除数字n的二进制表示中的最后一个1
n & (n - 1);
前缀和
int n = nums.length;
vector<int> pre_sum(n + 1, 0);
pre_sum[0] = 0;
for (int i = 0; i < n; ++i) {
pre_sum[i + 1] = pre_sum[i] + nums[i];
}
FloodFill算法（二维矩阵中的搜索问题）
// (x, y)为坐标位置
void fill(int x, int y) {
fill(x - 1, y); // 上
fill(x + 1, y); // 下
fill(x, y - 1); // 左
fill(x, y + 1); // 右
}
并查集
class UF {
private:
int count;
vector<int> parent;
vector<int> size;
public:
UF(int n) {
this->count = n;
for (int i = 0; i < n; ++i) {
parent.push_back(i);
size[i] = 1;
}
}
void union(int p, int q) {
int root_p = find(p);
int root_q = find(q);
if (root_p == root_q) {
return;
}
if (size[root_p] > size[root_q]) {
parent[root_p] = root_p;
size[root_p] += size[root_q];
} else {
parent[root_p] = root_q;
size[root_q] += size[root_p];
}
--count;
}
bool connected(int p, int q) {
int root_p = find(p);
int root_q = find(q);
return (root_p == root_q);
}
int find(int x) {
while (parent[x] != x) {
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
int count() {
return count;
}
};
2860
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
