BraketBN

【题目链接】定理题.../* Think Thank Thunk */#include #include #include using namespace std;typedef long long LL;const int maxn = 105, p = 1000003;int n, fact[200005], A[maxn][maxn], du[maxn];

【题目链接】随便建.../* Think Thank Thunk */#include #include #include using namespace std;const int maxn = 205, maxm = 250005, maxq = 100005, inf = 0x3f3f3f3f;int n, m, head[maxn], cnt, bg, ed,

【题目链接】【POPOQQQ的题解】被卡题意了。。/* Think Thank Thunk */#include #include #include using namespace std;typedef long long LL;const int maxn = 1005, maxm = 5000005, maxq = maxn;const LL linf =

【题目链接】对于数字i，在1到n中，一共有n / i个数是i的倍数。/* Think Thank Thunk */#include #include #include using namespace std;inline int iread() { int f = 1, x = 0; char ch = getchar(); for(; ch '9'; ch = g

【题目链接】被卡的不要不要的= =hzwer的建图似乎是错的，按照这个过了【jiangyuze831的题解】/* Think Thank Thunk */#include #include #include using namespace std;const int maxn = 4005, maxm = 4100005, maxq = 100000, i

【题目链接】先跑最大流，然后在残量网络上跑最小费用最大流。/* Think Thank Thunk */#include #include #include using namespace std;const int maxn = 1005, maxm = 20005, maxq = 100000, inf = 0x3f3f3f3f;int n, m, k, cur[ma

【题目链接】【POPOQQQ的题解】跑了倒数rk5.../* Think Thank Thunk */#include #include #include using namespace std;typedef long long LL;typedef unsigned long long ULL;const int maxn = 500005;int n,

【题目链接】清空时候忘把边清空了= =RE无数发另外计算的时候还得算根节点...【ydc的题解】/* Think Thank Thunk */#include #include #include using namespace std;const int maxn = 10005;int n, head[maxn], cnt, q[maxn], dp[ma

【题目链接】有点神...【BLADEVIL的题解】/* Think Thank Thunk */#include #include #include using namespace std;const int maxn = 1605, maxm = 300005, maxq = 500000, inf = 0x3f3f3f3f;int n, m, head[m

【题目链接】设dp[i][a1][a2][b1][b2]表示，前i个食物，第一个矿场最后两次的食物分别为a1、a2，b1、b2同理，所得到的最大煤炭数。/* Think Thank Thunk */#include #include #include #define rec(i, x, y) for(int i = x; i <= y; i++)using namespac

【题目链接】简单DP。。注意输出不能有换行。/* Think Thank Thunk */#include #include #include using namespace std;typedef long long LL;const int maxn = 55;int n, m;bool g[maxn][maxn];inline LL gcd(LL a,

【题目链接】考虑比较暴力的方法，我们枚举两个集合的最大值S1, S2，那么我们可以用2-SAT来判断合法不合法（如果i, j之间的值大于S1，那么如果i在第一个集合，j只能在第二个集合，其他类似）。我们将边权从大到小排序，依次枚举S1，发现S2是单调的（S2越大，越可能合法），于是可以二分S2了。另外还有个优化，把枚举S1的过程看成加边的过程，我们发现当这个图不是二分图的时候就可以

【题目链接】从Claris那里学来的扫描线做法。/* Think Thank Thunk */#include #include #include #include using namespace std;typedef long long LL;const int maxn = 80005;int n, m;LL ans;struct data

【题目链接】记录每个盒子被哪些熊孩子的区间覆盖，用链表存起来。又因为熊孩子的区间是连续的，所以用线段树优化一下就行了。注意空间大小，不然容易RE WA/* Think Thank Thunk */#include #include #include using namespace std;typedef long long LL;const int max

【题目链接】int开成bool，调了半天...设ok[i][j]表示模板串[i, j]这段是否能被删除完，再设dp[i]表示模板串[1, i]删除之后最少剩多少字母，那么显然有dp[i] = dp[i - 1] + 1if(ok[j][i]) dp[i] = min(dp[i], dp[j - 1])现在考虑如何得到ok[i][j]。设f[i][j][k][

【题目链接】显然四个点都在凸包上，按逆时针设为i, a, j, b，枚举i和j，a和b都是单调的，复杂度为O(n^2)闲得无聊写了个暴力。。/* Forgive me Not */#include #include #include using namespace std;typedef long double LD;typedef double DB;

【题目链接】调了4个小时多.../* Forgive me Not */#include #include #include using namespace std;const int maxn = 100005, maxl = 5000005, maxq = maxn;int n, q[maxq];char str[maxl], tmp[maxl];struc

【题目链接】看了半天题才看懂...题解：设dp[i][j]表示FJ走到第i步，Bessie走到第j步时，的最小花费。那么从dp[i][j]向dp[i + 1][j]，dp[i][j + 1]，dp[i + 1][j + 1]转移就完了。复杂度：时间复杂度O(nm)，空间复杂度O(nm)收获：要留意到无后效性/* Forgive me

【题目链接】感觉和BZOJ1015差不多。。题解：倒着考虑操作，就变成了加边。记录当前时刻有多少个连通块，如果有一个，那么答案是YES，否则是NO。对于当前点，把当前点与已经添加进的点合并。每合并一次，连通块减一。（一开始连通块先++）复杂度：时间复杂度O(n+mα(n))空间复杂度O(n+m)收获：当两个点已经在一个并查集里的时

【题目链接】以为adjacent是不同的意思，结果是相邻23333，写了个贪心WA了一发。题解：设dp[l][r]表示将l和r合并之后，得到的最大的数，于是就可以转移了dp[l][r] = dp[l][k] + 1（dp[l][k] == dp[k + 1][r]）另外还有贪心写法，只不过太麻烦了...话说好像写记忆化搜索的会被卡。。复杂度：时间

第一次写游记。Day0和yzx，hjs一块，早上7点飞机，上了飞机一直睡...醒来后差不多已经降落了。从机场坐地铁，到北大站。（原来圆明园和中关村都在北大旁边呀）先去了宾馆，结果前台告诉我们房间还没退出来，由于肚子有点饿，就去对面的KFC填了填肚子。到了13点房间才空下，把东西放好，睡了会。起来14点半，去北大报道。北大好大啊...腿都没劲了orz找到了理科

【题目链接】pkusc时候做的题，现在发上来。每个节点维护一个大根堆，维护从根节点到当前节点以及当前节点的子节点的路径长度（即深度）。如果当前节点的堆的堆顶 - 当前节点的深度 大于L，那么删除堆顶，直到满足条件为止。那么堆的size就是当前节点的答案。当一个节点处理完毕后，把当前节点的堆与当前节点的父亲的堆合并，就可以了。当一个节点的儿子都处理完后，那么就可以

【题目链接】大水题竟然WA了2发。。（1）二分找到位置后，贡献应该是id - l...（2）被卡精度了/* Forgive me Not */#include #include #include using namespace std;typedef long long LL;const int maxn = 100005;int n, num[max

【题目链接】奇怪的二分。考虑给白边的边权加上一个数，这个数越大，MST时选的白边就越少。注意排序时候，如果边权相等，要先选白边。/* Forgive me Not */#include #include #include using namespace std;const int maxn = 50005, maxm = 100005, inf = 0x3f3

【题目链接】比较有意思...经典的组合数取模问题，我们用质因数分解解决。低位的计算就不说了，直接快速幂取模就可以。对于高位的计算，我们计算log10下的答案，即log10(p1^a1*p2^a2*...*pk^ak) = a1*log10(p1) + a2*log10(p2) + ... + ak*log10(pk)记上式为ans，那么答案应该为10^ans，但是我们只要最

【题目链接】算是比较经典的区间DP，比较重要的思路是，把未来的花费放到现在计算。一开始写了个空间O(n^2)的记忆化搜索，结果被卡内存了，最后换成循环了.../* Forgive me Not */#include #include #include using namespace std;const int maxn = 3001, inf = 0x3f3f3f

【题目链接】经典区间DP。首先添加一个字符和删除一个字符是等价的，因为在一个位置添加一个字符，就等价与在对称回文的位置删除一个字符，删除同理。那么我们只需要考虑删除字符。设dp[l][r]表示将[l, r]改为回文串的最小代价，那么有（1）dp[l][r] = min(dp[l + 1][r] + cost[str[l]], dp[l][r - 1] + cost[str[r]

【题目链接】怎么选到了这么水的题.../* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 10005;int n;struct _data { int l, r; bool operator < (const _da

【题目链接】设dp[i][j]，表示前i个位置，花费为j，的最大有趣指数。然后类似背包一样转移。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 1005, maxm = 10005;int L, n, m, dp[maxn][ma

【题目链接】n = a^2 + b^2 + c^2 + d^2。暴力枚举a，b，c，都是sqrt(n)级别的，然后判断d^2是否是完全平方数。/* Telekinetic Forest Guard */#include #include #include #include using namespace std;int n, m;inline int iread

【题目链接】对于一条边(u, v)，经过这条边的次数为(1到u的路径个数)*(v到n的路径个数)。正反跑两次拓扑序，然后枚举边，统计答案。一开始以为(1到u的路径个数)就是经过边(u, v)的次数，结果WA啦。/* Telekinetic Forest Guard */#include #include #include #include using names

【题目链接】NOIP2014D1T2是从这个题改的吧。。题解：首先可以发现，满足条件的点对一定是“有一个中心点，三个点到中心点的距离相等，且三个点分别在不同子树中”这种情况。那么枚举中心点，然后遍历子树，统计答案。d[i]为临时数组，表示当前子树中深度为i的点有多少个。d1[i]表示，当前点已经遍历过的子树中，深度为i的点有多少个。d2[i]表示，当前点已经遍历过的子树

【题目链接】【hzwer的题解】维护转移位置的数组有点神。。/* Telekinetic Forest Guard */#include #include #include #include using namespace std;const int maxn = 40005, inf = 0x3f3f3f3f;int n, m, num[maxn], dp[max

【题目链接】数据范围都特别小，直接暴力就可以搞了。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 605, maxl = 27, maxm = 305;int n, m, dp[maxm], wlen[maxn];char word

【题目链接】【hzwer的题解】orz倍增求lca，根节点的深度不能从0开始。线段树手滑打跪了orz，WA1发。/* Telekinetic Forest Guard */#include #include #include #include #include #include using namespace std;typedef pair pii;c

【题目链接】太神啦。【POPOQQQ的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 6005, maxm = 300005, maxe = 2505, maxq = 10000, inf = 0x3f3f3f3f;int n,

【题目链接】【tunix的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 105, maxm = 18, maxs = 1 << 16, inf = 0x3f3f3f3f;int n, m, dp[maxn][maxs],

【题目链接】【tunix的题解】枚举力矩和、拿走橡皮的个数，然后就变成整数拆分问题了。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 10005, maxk = 12;int n, k, p, dp[maxn * maxk][

【题目链接】好像是比较经典的题了。第一次在考场上写三分orz。/* Telekinetic Forest Guard */#include #include #include #include #include using namespace std;typedef double DB;const DB eps = 1e-6;struct po {

【题目链接】公式为：设 ans = ∑(n! / ((d!)^(n/d)*(n/d)!))则答案为m ^ ans证明：考虑现在有d * k个点，d代表每个团的点数，那么k就是个数了，记方案数为Ak。然后现在又来了d个点，记方案数为Ak+1。（即现在有n = d * (k + 1)个点）我们选择一个点，让这个点与其他的d - 1个点组成团，方案数为C(d *

【题目链接】直接暴力就可以了，复杂度O(n*10+m*len*10)/* Telekinetic Forset Guard */#include #include #include using namespace std;const int maxn = 205, maxl = 1300005;int n, m, son[maxn][26], cnt;bool

【题目链接】【thy_asdf的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;LL n, k, m, p;inline LL qpow(LL a, LL n) { LL res = 1; for(; n

【题目链接】听说是网络流24题。。【rausen的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 2005, maxm = 10005, maxq = 10000, inf = 0x3f3f3f3f;int n, A, B,

【题目链接】原来那个板有问题...重新写了下。把分解质因数写挂了，WA了一次.../* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;const int maxn = 10;LL w[maxn];inlin

【题目链接】还是python好用【大爷的题解】def A(n): res = 1 for i in range(1, n + 1): res *= i return resdef C(n, m): if n < m: return 0 return A(n) // A(m) // A(n - m)n, m = [int(i) for i in raw_inpu

【题目链接】这个质因数分解劲啊【xkui的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;const int maxn = 2000005;int n, m, p, prime[maxn], mn[maxn]

【题目链接】学习一发旋转卡壳。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 50005;int n, m;struct Vector { int x, y; Vector(int a = 0, int b = 0)

【题目链接】数据结构学多了，看到题解发现3个前缀和就搞定了。弱智+2另外也可以线段树，也可以3个主席树。。。莫队：/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 100005, maxsqrtn = 316;i

【题目链接】【VFK的题解】边界条件可以用样例推出来。首先m = 0时是1（即空空间）然后n = 1时是m * 2（用样例画一画）由递推式可以得到n = 0时是2。/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;

【题目链接】题解待补/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 100005, maxq = maxn;int n, q[maxq], ans, dp[maxn], id[26];struct _ptree { in

【题目链接】同【BZOJ1271】但是读入是NOI难度。#include #include #include using namespace std;typedef long long LL;const int maxn = 200005;int n;char str[10000];struct _data { int s, e, d;} p[maxn];

【题目链接】学习一发建图。这篇题解比较详细【zarxdy34的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxg = 45, maxn = 70005, maxm = 150005, maxq = 100000, inf = 0x3f3

【题目链接】没写过dfs的spfa，写一发。01分数规划裸题。/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef double DB;const int maxn = 3005, maxm = 10005;const DB inf = 1

【题目链接】比较经典的模型。先高斯消元求出经过每个点的期望次数，每条边经过的期望次数为两个端点经过的期望次数除以各自的度数。然后按照经过次数贪心编号。注意走到n点之后不会再继续走了。/* Telekinetic Forest Guard */#include #include #include #include using namespace std;typ

【题目链接】手画一下样例就有点感觉了。一开始定了二维的状态，发现答案跑不对，后来意识到需要第三维，表示当前区间最后一个填的数是最左边的还是最右边的，然后就可以转移了。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 1005,

【题目链接】合并时候启发式合并就可以了。注意第9个点第99999个合并操作连接了0 0...调了好长时间= =/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 100005;int n, m;int son[maxn][2],

【题目链接】二分最大边权，把不大于mid的边做个生成树。因为只要保证最大值不超过mid即可，具体边权、边权总和无所谓的。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 10005, maxm = 20005;int n,

【题目链接】把每个颜色的下标存到set里。考虑合并两个颜色，每次把size小的颜色合并到size大的颜色。但是考虑下面这情况，比如现在要把1刷成2，但是1的size比2的size大，这时我们仍把2合并到1，那么以后对颜色2的操作，我们就要对颜色1进行了。所以我们开一个数组fa[u]，存的是颜色u实际对应的颜色。/* Telekinetic Forest Guard */

【题目链接】原来矩阵快速幂还可以分段玩。/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;LL n;int p; struct mat { int num[3][3];} E, ans;inline LL mu

【题目链接】题意：求凸包，求面积，然后给面积除以50，向下取整。用的Andrew算法，即跑两次，先求出下凸包，然后再求出上凸包。求面积时候应该用凸包数组求，结果写成了原来的点的数组，调了20多分钟。弱智+2/* Telekinetic Forest Guard */#include #include #include #include using namespa

【题目链接】可以参考《浅谈无向图最小割问题的一些算法及应用》王文涛然而并没有建树/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 155, maxm = 30005, maxq = 10000, inf = 0x3f3f3f3f

【题目链接】设atr[u]表示，从根节点到u节点，缩小了多少次，即一路上每个节点的儿子个数之积。设val[u]表示，atr[u] × u的权值。val相等的点，如果其中一个点不改变权值的话，那么其他的点都不用改变。那么我们取val的众数，用n减去众数的个数就是答案。由于atr和val太大了，所以要取log。/* Telekinetic Forest Guard

【题目链接】类似最大乘积生成树那样做，只不过是把求生成树改成了求完美匹配。【chenyushuo的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 75, inf = 0x3f3f3f3f;struct po { int

【题目链接】大爷的题解【POPOQQQ的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 300005, maxm = 1000005, inf = 0x3f3f3f3f;int n, head[maxn], cur[maxn

【题目链接】学习一发计算几何基础。/* Telekinetic Forest Guard */#include #include #include #include using namespace std;typedef double DB;const int maxn = 50005;const DB eps = 1e-6;struct _line { D

【题目链接】一棵树，每个边有黑白两种颜色，要支持三种操作1 一条链上的颜色取反2 只有一个顶点在一条链上的边的颜色取反3 查询一条链上黑色边的个数两个线段树，分别维护重链的颜色，轻链的颜色。重链的两个端点需要分别讨论。/* Telekinetic Forest Guard */#include #include #include using n

【题目链接】很容易发现是贪心，问题在于如果两个字符相等时我们要继续向下比较，这样最坏是O(n^2)的，可以通过BZOJ1640。然后我们就需要一个快速比较字典序的工具了，后缀数组可以。好久没敲，板都快忘了。/* Telekinetic Forest Guard */#include #include #include using namespace std

【题目链接】一开始写了个莫队+树状数组，T飞了。需要对权值分块，然后分块查询。/* Telekinetic Forest Guard */#include #include #include #include using namespace std;const int maxn = 100005, maxm = 1000005;int n, m, num[max

【题目链接】一开始以为R必须连续，敲了一发，结果发现样例1挂了...然后看了【hzwer的题解】，原来要这么写= =/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 55, inf = 0x3f3f3f3f;int dp[maxn][m

【题目链接】果然还是打表找规律比较靠谱。【heheda的题解】%一发正在省选中的SD神犇。/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;const int maxn = 105;int pos[maxn], to

【题目链接】太神了【将狼踩尽的题解】/* Telekinetic Forest Guard */#include #include using namespace std;typedef long long LL;const int maxn = 2000001, p = 20100403;int n, m, fact[maxn];inline int mul(

【题目链接】1A。/* Telekinetic Forest Guard */#include #include using namespace std;typedef long long LL;struct _mat { LL num[2][2];} trans, E;inline LL mul(LL a, LL b, LL p) { return (a *

【题目链接】题解：第一眼觉得是裸最小割模型，写了之后发现样例跑出个5000...问了神犇，才知道：1 相同地之间也得加容量为A的边，因为一开始的高低地不能决定最后策略的高低地。2 要加双向边，因为一开始并不知道某个点应该属于S集还是T集。复杂度：时间复杂度：O(maxflow(n, m))，空间复杂度O(n + m)1WA：相同地之间也得

【题目链接】题解：暴力。刻章只存x的位置，这样复杂度小点。复杂度：时间复杂度：O(nm*刻章里x的个数)，空间复杂度：O(nm+ab)3WA：时间戳写挂了。GET：一定要注意时间戳。/* Telekinetic Forest Guard */#include #include #include using nam

【题目链接】题解：最坏情况指的是出错位置始终在最长的区间里。为了使时间最少，我们每次一定是尽量均分区间。设dp[n]表示，在最坏情况下，处理n行代码所需要的最少时间。那么有dp[n] = min{(i - 1) * p + dp[ceil(n / i)]} + r意义是，将n行代码分成i块，那么需要加i - 1个printf，然后对最长的区间递归处理。直接枚举i是O

【题目链接】题解：直接用CDQ分治是O(nlog^2n)的，似乎可以过。一种O(nlogn)的做法，考虑补集转化，答案 = 总对数 - 不满足条件的对数。考虑不满足条件的数的性质，这一对数在其中两个排列里的位置关系是相同的，在另一个排列里的位置关系相反。那么统计两两排列之间不满足偏序关系的数对的个数，这样统计下来每对数都被统计了两次，除以2就是不满足条件的对数。

【题目链接】题解：把算式和对应的数连边，跑二分图匹配。要先离散化一下数字，或者用map。复杂度：时间复杂度：O(二分图匹配)，hungary是O(nm)。空间复杂度：O(n + m)。1A。GET：有算式，有数字，要连接起来，且不相同，那么就是匹配。/* Telekinetic Forest Guard */#inclu

【题目链接】先把Xi排序，四种操作都不会改变Xi的相对顺序，这样L和R就是在左边和右边出现了，方便区间赋值。然后各种标记传一传就行了。赋值标记可以变为 乘法标记 = 0，加法标记 = 要赋的值，这样就可以少传一个标记。/* Telekinetic Forest Guard */#include #include #include using namespace std

【题目链接】一眼模拟+贪心，算了算复杂度，好像不太对呀...大概是O(n * m + Q + n + m + 1 + n * m)。。嘿嘿嘿。/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long long LL;const int

【题目链接】将排序好的后缀列出来，每次比较相邻后缀的第二个字符开始的后缀的rank，如果排在前面的后缀的第二个字符开始的后缀的rank比排在后面的大，那么显然后面的后缀的第二个字符就要+1了。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int ma

【题目链接】参考了【wuyuhan的题解】记m = ∑wi对于n 对于n > 300的情况，暴力O(n)枚举矩形的上边界，然后枚举暴力O(m)枚举高度（最大全0子矩阵单调栈做法的高度），最后对于每个高度，O(m)计算矩形内的答案。计算答案的过程是：枚举每一个矩形，计算出所有矩形左边界和右边界能向内延伸的最大值和次大值，记录次大值的原因是，如果左边界右边界最大值的

【题目链接】对于怪物u，普通攻击打死后产生的怪物为vi。设dis[u]表示打死u的最小花费，那么有dis[u] = min{s[u] + ∑dis[vi], k[u]}以这个为松弛条件，跑spfa就可以啦。然而BZOJ跑了29s...变为倒数rank1/* Telekinetic Forest Guard */#include #include #includ

【题目链接】可以发现，购买方案是有周期的，周期个数即为购买次数。对于固定的购买次数，我们可以贪心的求出最多存活多少天。但是我们并不知道要购买多少次，反正是个函数最值问题，直接模拟退火！看了题解之后，发现购买次数与答案为单峰函数关系，那么可以换成三分法了。。贪心的话，先预处理出每次要购买的食物（因为有些食物一定不会去买的），然后在保质期内，贪心的全买这种食物即可。

【题目链接】一开始写了个二分a+最短路b，骗了65分，然后改成二分b+最短路a，骗了70分。。发现二分是不对的之后，给答案取min，骗到了90分。出题人太不负责任了。正解是枚举a，用LCT维护b的最小生成树。/* Telekinetic Forest Guard */#include #include #include using namespace std;

【题目链接】题解：首先得有一个结论：设个数大于s的数字有k个（如果k大于c，显然是TAK。这里讨论k 数字和不小于(c - k) * s，那么一定有解。并不会证明...用树状数组记录一下数字的个数以及数字的数字和，然后判断就可以了。复杂度：时间复杂度：O(mlogm)，空间复杂度：O(m)。1A。GET：结论题.../* Te

【题目链接】题解：如果区间[j, i]固定，那么一定是将权值最大的一段变为0。用单调队列维护一段区间内权值最大的子段下标（这里记录右端点下标，设为x），枚举右端点i，用尺取法计算出j。一段区间[j, i]合法的条件是sum[i] - sum[j - 1] - (sum[x] - sum[x - d]) 复杂度：时间复杂度：因为每个点最多遍历2次，复杂度为O(n)

【题目链接】点分治。考虑经过点x的路径，对于x，用类似TreeDP的方法，记录no[d]，表示路径长度为d时经过边最少的点的编号。对于已经走过的子树，更新no。对于当前子树，遍历到一个点v，用depth[no[k - dis[v]]] + depth[v]更新答案。注意给no清零时，用dfs姿势清零，这样做是O(n)的。如果直接用for或者memset，这样做是O(k)的，

【题目链接】看到数据范围以为是O(n)做法，再看看status似乎带了个log？然后去搜题解，没想到是线段树= =。题解：设pre[i]表示与i这个位置上的数相等的前一个数的下标。用线段树维护答案。枚举右端点，每次加入一个数，那么pre[i] + 1到i这段位置的答案加上这个数的权值，pre[pre[i]] + 1到pre[i]这段位置的答案减去这个数的权值，然

【题目链接】题解：很容易想到O(n^2)DP的做法。（1）A[i] == B[j]，dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1（2）A[i] != B[j]，dp[i][j] = dp[i - t + 1][j - t + 1] + t，t表示最长的一段不相等的数的长度发现如果连续的一段内要填写的两个数都不相同，那么一定是贪

【题目链接】题解：因为和回文串定义类似，且数据范围很大，那么就可以想到是Manacher了。把增加回文半径那里的判断条件改改就可以了。复杂度：时间复杂度O(n)，空间复杂度O(n)。WA：因为答案只可能是偶数串，更新mx那里还得判断，WA了3发。GET：自己想到了用Manacher，也注意到答案只可能是偶数串。但是写挂了2333，

【题目链接】十年OI一场空，APIO见祖宗。点分治没有什么特殊的地方。在计数的时候，将边权模3，统计在模3意义下的深度，设tim[x]表示深度为x的点的个数，那么答案为tim[1] * tim[2] * 2 + tim[0] * tim[0]。/* Telekinetic Forest Guard */#include #include #include using

【题目链接】/* Telekinetic Forest Guard */#include #include using namespace std;typedef long long LL;inline void exgcd(LL &x, LL &y, LL a, LL b) { b ? (exgcd(y, x, b, a % b), y -= a / b * x) :

【题目链接】【题目链接】类似与链表那样搞一搞就可以了。注意有可能跑到第n + 1个点，于是也要给这个点赋个father。/* Telekinetic Forest Guard */#include #include #pragma comment(linker, "/STACK:102400000,102400000")using namespace std;

【题目链接】不会什么考什么，赶紧学发莫队。/* Telekinetic Forest Guard */#include #include using namespace std;typedef long long LL;const int maxn = 50005, sqrtn = 223;int n, m, k, num[maxn], cnt[maxn];L

【题目链接】有一个结论：如果答案不是Infinity，那么最长回文子串只可能出现在一个串里，或者两个串拼接一次形成的串里。那么我们枚举每个串的每个回文中心，对于剩下的不在回文串里的子串，去其他串里找一个拼接串，看能不能形成更大的回文串。于是我们需要一个快速查询LCP的数据结构，选择后缀数组+ST表就可以了。但是这样做复杂度还是比较高，于是我们考虑用图论模型优化。先把单个串是回文

【题目链接】显然是一个约束条件下多元函数最值问题，那么就用拉格朗日乘数法就行了。然后二分lambda的值，解方程。具体见POPOQQQ大爷的题解【POPOQQQ的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef long double

【题目链接】同【CodeChef-CSEQ的题解】/* Telekinetic Forest Guard */#include #include #include using namespace std;typedef unsigned long long ULL;const int maxn = 1000505;const ULL p = 1000003;ULL

【题目链接】可以证明，如果有A->B->C，那么A->C一定不是最优的。然后搞一搞就行啦。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 200005, maxm = 1005, inf = 0x3f3f3f3f;int n, m

【题目链接】大水题。/* Telekinetic Forest Guard */#include #include #include using namespace std;const int maxn = 100005, inf = 0x3f3f3f3f;int n, m;int son[maxn][2], pre[maxn], size[maxn], va

【题目链接】发现每次询问其实相当于，问dfs序在一段区间内，深度在一段区间内的点的贡献是多少，这个是经典的二维矩形求和的问题。因为数据比较大，考虑用主席树来维护这个信息。我们用主席树维护深度，权值为贡献，然后按DFS序加点进去，最后区间查询就可以了。/* Telekinetic Forest Guard */#include #include #include u