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.树中所有节点到重心的距离之和最小，如果有两个重心，那么他们距离之和相等； 两个树通过一条边合并，新的重心在原树两个重心的路径上； 树删除或添加一个叶子节点，重心最多只移动一条边； 一棵树最多有两个重心，且相邻。 思路 如果找到只有一个重心，那么直接删一个重心的直连边然后加回去就好了。 如果找到两个重心，那么在其中一个重心上找到一个直连点不是另一个重心，删除连另外一个就好了。 如何求树的重心？ 先任选一

原理 https://blog.csdn.net/alexfaker/article/details/90199074 模板 https://www.cnblogs.com/iloveori/p/12526461.html#%E8%A7%82%E5%89%8D%E6%8F%90%E7%A4%BA%EF%BC%9A%E8%AF%B7%E4%B8%8D%E8%A6%81%E5%9C%A8%E8%B4%9F%E6%9D%83%E5%9B%BE%E4%B8%AD%E7%86%9F%E7%BB%83%E7

原题链接 https://codeforces.com/contest/1406/problem/D 思路 样例中a=2,-1,7,3; 差分为-3,8,-4; 设(b[1]=x)+(c[1]=y)=a[1]; ∵b[1]=c[2]>=…>=c[n] x+(y-3)=(x-1)+(y-2)=(x+1)+(y-4)=…=a[2] ∴b[2]=x c[2]=y-3为最优解 其他的解都会导致b[n]或者c[1]变大 使最后答案不是最小 即:差分>0时,将差分的

络谷 P1962 斐波那契数列

络谷 P3379 [模板] 最近公共祖先 LCA 欧拉序+线段树 int cnt; int dep[maxn]; int eoo[maxn]; int ooe[maxn << 1]; void dfs_ooe(int u, int f) { dep[u] = dep[f] + 1; ooe[++cnt] = u; eoo[u] = cnt; for (int i = head[u]; ~i; i = edge[i].nxt) { int v = edge[i].v; if (f ==

题解 [该代码需要配合线段树] int cnt; int fa[maxn]; int dep[maxn]; int siz[maxn]; int son[maxn]; int rk[maxn]; int top[maxn]; int id[maxn]; inline void init_tree() { cnt = 0; } void dfs_ss(int u) { int ms = -1; int mss = 0; siz[u] = 1; for (int i = head[u]; ~i; i

#ifdef __cpp_if_constexpr template <typename T, typename… Args> void read(T& x, Args&… r) { if constexpr (is_integral_v<T> && !is_same_v<decay_t<T>, char>) { x = 0; lli f = 1; char ch = getchar(); while (!i

目录1 条款 01：视 C++ 为一个语言联邦2 条款 02：尽量以 const、enum、inline 替换 #define3 条款 03：尽可能使用 const4 条款 04：确定对象被使用前已先被初始化5 条款 05：了解 C++ 默默编写并调用那些函数6 条款 06：若不想使用编译器自动生成的函数，就该明确的拒绝他们7 条款 07：为多态基类声明 virtual 析构函数8 条款 08：不要让异常逃离析构函数9 条款 09：绝不再构造和析构过程中调用 virtual 函数10 条款 10

放在代码的最前面，感受性能加速吧！

#include <cstdio> #include <cstring> using namespace std; const int MOD = 1e4; const int MAXN = 12; struct Mat { long long mat[MAXN][MAXN]; int n, m; Mat operator * (const Mat &b) const { Mat a = *this; Mat ans; ans.n = a.n; ans.m = b

dfs(数的最后若干位,各种限制条件,当前第几位) if 最后一位 return 各种限制条件下的返回值 局部变量 ct=当前位的数字 局部变量 sum=0; for i=0 to ct-1 sum+=当前位取i时一定无无限制的合法状态数 sum+=当前位取i时满足当前限制的合法状态数 根据ct更新限制条件 不再满足则return sum return sum+dfs(当前位后的若干位,更新后的限制条件,下一位) slv(当前数) if(只有一位) return 对应的贡献 局部变量 ct; f

目录1 原型2 解释2.1 BackBufferWidth 和 BackBufferHeight2.2 BackBufferFormat2.3 BackBufferCount2.4 MultiSampleType 和 MultiSampleQuality2.5 SwapEffect2.6 hDeviceWindow2.7 Windowed2.8 EnableAutoDepthStencil2.9 AutoDepthStencilFormat2.10 Flags2.11 FullScreen_Re

目录1 准备1.1 下载源码1.2 解压源码1.3 编译源码2 样例2.1 准备2.2 配置项目2.2.1 配置 – 所有配置2.2.2 配置 – Release2.2.3 配置 – Debug2.3 放入动态链接库2.4 运行程序2.5 关于X643 参考视频 准备 下载源码 下载地址：http://www.wxwidgets.org/downloads/ 选择 Source Code > Windows 7z 下载 解压源码 解压 wxWidgets

目录1 源文件头部注释2 函数头部注释3 数据结构声明的注释4 全局变量的注释5 对代码的注释 源文件头部注释 列出：版权、作者、编写日期和描述。 每行不要超过80个字符的宽度。 示例： /************************************************* Copyright:Call_Me_Why Author:why Date:2010-08-25 Description:Something about C++ ************************

题目链接

题目链接

题目链接 #include <cstdio> #include <cstring> #include <queue> #include <cmath> using namespace std; const int MAXN = 1e5 + 100; const int MAXM = MAXN << 2; struct node { int u, v, nxt; } edge[MAXM]; int head[MAXN]; int tot,

给出两个矩阵A和B。 A的长是N1，宽是M1；B的 长是N2，宽是M2。

该怎样去加速幂运算的过程呢？既然我们觉得将幂运算分为n步进行太慢，那我们就要想办法减少步骤，把其中的某一部分合成一步来进行。

struct prime_t { vector<bool> pri_flg; // 素数表 pri_flg[i] 表示 i 是否为素数 vector<lli> pri_tab; // 素数表 pri_tab[0~num] 保存着 0 ~ n 中的素数 prime_t(lli n) : pri_flg(n + 1, true) { // 重置素数表 假设都是素数 pri_flg[0] = pri_flg[1] = false; // 规定 0 和 1 不是素数 for (l