目录1 加锁的原则1.1 规则10.1 多线程 进程并行访问共享资源时 一定要加锁保护1.2 规则10.2 锁的职责单一1.3 规则10.3 锁范围尽量小 只锁对应资源操作代码1.4 规则10.4 避免嵌套加锁 如果必须加锁 务必保证不同地方的加锁顺序是一样的1.5 建议10.1 进程间通讯 使用自己保证互斥的系统1.6 建议10.2 可重入函数尽量只使用局部变量和函数参数 少用全局变量 静态变量1.7 建议10.3 锁中避免调用函数 如果必须调用函数 务必保证不会造成死锁1.8 建议10.4

一键跳转至题目 题目描述 机器上有 $n$ 个需要处理的任务，它们构成了一个序列。这些任务被标号为 $1$ 到 $n$，因此序列的排列为 $1 , 2 , 3 \cdots n$。这 $n$ 个任务被分成若干批，每批包含相邻的若干任务。从时刻 $0$ 开始，这些任务被分批加工，第 ii 个任务单独完成所需的时间是 $T_i$ 。在每批任务开始前，机器需要启动时间 $s$，而完成这批任务所需的时间是各个任务需要时间的总和。 注意，同一批任务将在同一时刻完成。 每个任务的费用是它的完成时刻乘以一个费

传送门

洛谷P4781 题解公式 inline int FastPow(int x, int y) { if (y == 1) return x; if (!y) return 1; int tmp = FastPow(x, y >> 1) % mod; return tmp * tmp % mod * (y & 1 ? x : 1) % mod; } inline void Lagrange() { go(i, 1, n, 1) { up = down = 1; go(j, 1,

洛谷P3834 教程视频 #pragma once #include<algorithm> #include<bitset> #include<cmath> #include<cstring> #include<cstdlib> #include<cstdio> #include<complex> #include<fstream> #include<iostream> #include&

洛谷P3375 #pragma once #include<algorithm> #include<bitset> #include<cmath> #include<cstring> #include<cstdlib> #include<cstdio> #include<complex> #include<fstream> #include<iostream> #include<ma

lli fac[maxn]; // 阶乘 lli inv[maxn]; // 逆元 lli invf[maxn]; // 逆元的阶乘 inline void init() { fac[0] = 1; for (lli i = 1; i < maxn; ++i) fac[i] = fac[i – 1] * i % mod; inv[1] = 1; for (lli i = 2; i < maxn; ++i) inv[i] = inv[mod % i] * (mod – mod / i)

struct fenwick_tree_t { lli n; vector<lli> tre; fenwick_tree_t(lli n) : n(n), tre(n + 1, 0) { } lli lowbit(lli x) { return x & -x; } void build(lli* arr) { for (lli i = 1; i <= n; ++i) upd(i, arr[i]); } void upd(lli i, lli x) { for (; i

lli gcd(lli x, lli y) { return y ? gcd(y, x % y) : x; }

使用 Tarjan 算法 lli fa[maxn]; lli dfn[maxn]; lli low[maxn]; bool cut[maxn]; void tarjan(lli u) { dfn[u] = ++cnt; low[u] = dfn[u]; lli child = 0; for (lli i = 0; i < mp[u].size(); ++i) { lli v = mp[u][i]; if (!dfn[v]) { ++child; fa[v] = u; tarjan(v);

std::chrono::system_clock::time_point bt = std::chrono::system_clock::now(); std::chrono::system_clock::time_point et = std::chrono::system_clock::now(); std::chrono::nanoseconds dt = std::chrono::duration_cast<std::chrono::nanoseconds>(et – bt

[ 络谷 ] lli dsu[maxn]; lli dis[maxn]; lli num[maxn]; void init_dsu() { for (lli i = 0; i < maxn; ++i) dsu[i] = i; for (lli i = 0; i < maxn; ++i) dis[i] = 0; for (lli i = 0; i < maxn; ++i) num[i] = 1; } lli find_dsu(lli x) { if (dsu[x] == x) r

约定存边方式为从左部到右部的有向边，左右部点编号相同 匈牙利算法 lli mch[maxn]; lli vis[maxn]; bool dfs_hun(lli u, lli dfn) { if (vis[u] == dfn) return false; vis[u] = dfn; for (lli i = head[u]; ~i; i = edge[i].nxt) { lli v = edge[i].v; if (mch[v] == 0 || dfs_hun(mch[v], dfn)) { mc

倍增思想 由 倍增 LCA 改的 lli mw[32][maxn]; lli fa[32][maxn]; lli dep[maxn]; void dfs_mw(lli u) { dep[u] = dep[fa[0][u]] + 1; for (lli i = 1; (1 << i) <= dep[u]; ++i) fa[i][u] = fa[i – 1][fa[i – 1][u]]; for (lli i = 1; (1 << i) <= dep[u]; ++

lli n; lli arr[maxn]; lli lg[maxn]; lli st[maxn][32]; inline lli flg(lli x) { if (lg[x]) return lg[x]; lli tmp = x; lli res = 0; while (tmp) tmp >>= 1, ++res; return lg[x] = res – 1; } inline void init_st() { for (lli i = 1; i <= n; ++i) st[

vector<int> bucket(1000001); void bsort(vector<int>& arr) { fill(bucket.begin(), bucket.end(), 0); for (int i = 0; i < arr.size(); ++i) ++bucket[arr[i]]; for (int i = 0, tot = 0; i < bucket.size(); ++i) for (int j = 1; j <= b

题目传送门 性质 删除重心后所得的所有子树，节点数不超过原树的1/2，一棵树最多有两个重心；2.树中所有节点到重心的距离之和最小，如果有两个重心，那么他们距离之和相等； 两个树通过一条边合并，新的重心在原树两个重心的路径上； 树删除或添加一个叶子节点，重心最多只移动一条边； 一棵树最多有两个重心，且相邻。 思路 如果找到只有一个重心，那么直接删一个重心的直连边然后加回去就好了。 如果找到两个重心，那么在其中一个重心上找到一个直连点不是另一个重心，删除连另外一个就好了。 如何求树的重心？ 先任选一