11 月做题记录

11.01-11.03

AT_arc153_c [ARC153C] ± Increasing Sequence

先赋值为 $1,2,3\ldots n$，然后找到一个 $abs$ 等于 $1$ 且代价相反的即可。

CF1103D Professional layer

首先只有不超过 $k=11$ 个质因子，然后我们每次暴力枚举消除的质因子集合，保留代价前 $k$ 小的即可，然后就能过了？？？

CF1476F Lanterns

经典老番，设 $f_i$ 表示前 $i$ 个灯的能覆盖的最长前缀是多少。

• 向右，$f_{i-1}\ge i$，$f_i=\max(f_{i-1},i+p_i)$。
• 向左，找到一个 $t$ 满足 $f_t\ge i-p_i-1$，则转移有 $f_i=\max(i-1,t+1+p_{t+1},\ldots (i-1)+p_{i-1})$。
• 虽然朝向了一个方向，但是贡献如有，$f_i=f_{i-1}$。

CF713E Sonya Partymaker

首先我们来一手二分，然后不难发现如果是一条链的话就是上一个题了，但是我们发现还有 $n\sim 1$ 的方法不好确定，我们考虑由于答案不超过 $\max(a_{i+1}-a_i)$，所以我们直接找出最大的区间当作 $n\sim 1$ 的间隔，然后分讨 $1$ 向左还是 $2$ 向左即可。

CF1366F Jog Around The Graph

首先我们肯定是走到某个边，然后来回刷分，我们直接设 $f_{i,j}$ 表示走了 $i$ 条边，在 $j$ 时最大经过的权值和即可。

然后后面的贡献是一个一次函数，建凸包即可。

CF1450H1 Multithreading (Easy Version)

首先，根据魔怔的贪心，我们可以首先每次选出相邻的两个颜色相同的配对，最后会剩下 abababab 的环，交点数量是 $\frac {cnt_b}2$，然后我们如果 $b$ 在奇数下标出现 $A$ 次，偶数下标出现 $B$ 次，则答案是 $\frac {|A-B|}2$。

然后假设奇数下标有 $A$ 个，偶数有 $B$ 个，确定的 $b$ 奇偶下标之差为 $val$，则

$$\begin{aligned} ans&=\frac 1 {2^{A+B-1}}\sum_{i=0}^A\sum_{j=0}^B[val+i-j\equiv 0\bmod 2]\frac {|val+i-j|}2\binom A i\binom B j\\ ans&=\frac 1 {2^{A+B}}\sum_{i=0}^A\sum_{j=0}^B[val+i-j\equiv 0\bmod 2]|val+i-j|\binom A i\binom B j\\ ans&=\frac 1 {2^{A+B}}\sum_{val-B\le t\le val+A,2\mid t}|t|\sum_{i=0}^A\sum_{j=0}^B[val+i-j=t]\binom A i\binom B j\\ ans&=\frac 1 {2^{A+B}}\sum_{val-B\le t\le val+A,2\mid t}|t|\sum_{i=0}^A\sum_{j=0}^B[val+i-(B-j)=t]\binom A i\binom B {B-j}\\ ans&=\frac 1 {2^{A+B}}\sum_{val-B\le t\le val+A,2\mid t}|t|\sum_{i=0}^A\sum_{j=0}^B[i+j=t+B-val]\binom A i\binom B j\\ ans&=\frac 1 {2^{A+B}}\sum_{val-B\le t\le val+A,2\mid t}|t|\binom {A+B}{t-val+B}\\ \end{aligned}$$

然后做完了。

CF878D Magic Breeding

我们枚举答案 $x$，把 $\ge x$ 变成 $1$，然后我们考虑 $2^k$ 种列，bitset 维护每种列的答案，转移可以 bitset 优化转移，复杂度 $O(\frac {q2^k}w+qk^2)$。

---

11.04-11.10

P7324 [WC2021] 表达式求值

首先我们对于每个下标分开考虑，考虑预处理出来 $2^n$ 种集合 $S$ 每种集合最后为 $1$ 的方案数，然后每位计算的时候，我们差分后计算每个位置的答案即可，复杂度 $O(m2^m+m^2n)$

AT_arc155_d [ARC155D] Avoid Coprime Game

我们考虑 dp，设我们当前在 $x$，那么我们考虑一个 $a_i$ 和 $x$ 的关系。

• $x\nmid a_i$，$x$ 变成 $\gcd(x,a_i)$。
• 否则我们考虑 $x$ 的倍数的奇偶以及操作次数的奇偶性即可。

我们考虑 dp，设 $f_{x,0/1}$ 表示当前为 $\gcd=x$，操作了奇数/偶数次即可。

转移我们考虑对于 $x$ 的每个因数 $d$，容斥计算是否存在 $a_i$ 使得 $\gcd(a_i,x)=d$ 即可。

有点抽象，放个代码：

Code

#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int N=2e5,M=N+5;
int n,a[M],f[M][2],cnt1[M],cnt2[M];
vector<int>vec[M];
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;++i) cin>>a[i],++cnt1[a[i]];
	for(int i=2;i<=N;++i)
		for(int j=i;j<=N;j+=i) vec[j].pb(i),cnt1[i]+=cnt1[j]*(i<j);
	for(int i=2;i<=N;++i){
		int sz=vec[i].size(),fl=0;
		for(auto v:vec[i]) cnt2[v]=cnt1[v];
		for(int j=sz-1;~j;--j){
			int x=vec[i][j];
			if(j<sz-1&&cnt2[x]!=0){
				if(!f[x][1]) f[i][0]=fl=1;
				if(!f[x][0]) f[i][1]=fl=1;
			}
			for(auto v:vec[x]) cnt2[v]-=cnt2[x];
		}
		if(!fl) f[i][cnt1[i]%2]=1;
	}
	for(int i=1;i<=n;++i) puts(f[a[i]][0]?"Aoki":"Takahashi");
}

P8180 「EZEC-11」Unmemorable

实际上，根据这个只需要根据 $r$ 数组，我们就能得到唯一的笛卡尔树形态。

我们对于 $r$ 前缀和得到 $sr$ 数组。

我们考虑全局最小值，发现他是最后一个满足 $sr_{i-1}=i-1$ 的 $i$。

然后后面的问题是类似的，递归即可，然后我们就建出笛卡尔树了，dp 是简单的。

P2481 [SDOI2010] 代码拍卖会

拆成若干段 $111111$，寻找循环节然后背包。

P3634 [APIO2012] 守卫

首先把不能放人的扔了，特判剩下全部放的情况。

然后套用经典贪心，只有这些被选择的点可能成为答案。

考虑怎么判断，把包含的区间删了，变成互不包含的，直接预处理一下前后缀信息即可。

LOJ 6268 分拆数

我们考虑 Ferrers 图，引一条 $y=x$ 的线，考虑多久离开图形，不妨设为 $h$，则两端分别是大小不超过 $h$ 的拆分数，即：

$$\prod_{k\ge 1}\frac 1 {1-x^k}=\sum_{h\ge 1}(\prod_{k=1}^h\frac 1 {1-x^k})^2$$

我们不难发现，当我们计算第 $n$ 项时，$h\le \sqrt n$，然后后面的生成函数我们直接算就行了，代码非常短，复杂度 $O(n\sqrt n)$。

常数非常小，计算 $1\sim 10^6$ 中每个数的拆分数本机下只需要 770 ms，如果只需要第 $10^6$ 项这一项，只需要 460ms

P8340 [AHOI2022] 山河重整

某些人不会 $O(n\sqrt n)$ 求互异拆分数还想打山河重整 /cf

考虑如何判断一个集合合法，当且仅当

$$\forall i\in[1,n],\sum_{j\le i}j\ge i$$

然后我们可以暴力 dp，$O(n^2)$。

然后我们考虑怎么做到更低复杂度，我们来手容斥，设 $f_i$ 表示在第一次在 $i+1$ 处不满足条件的方案数，即对于 $[1,i]$ 都满足上面的条件，$i+1$ 不满足，则答案就是:

$$2^n-\sum_{i=1}^nf_{i-1}2^{n-i}$$

然后我们考虑如何计算这个，首先我们考虑如果 $[1,i]$ 都满足，$i+1$ 不满足，则我们当前的权值和一定是 $i$，设我们凑出 $i$ 的方案数是 $g_{i}$，这个 $g$ 就是互异拆分数。

如何计算呢，考虑 Ferrers 图。

然后我们发现，对于互异拆分数，我们的列数即选的数的个数只有 $O(\sqrt n)$ 级别，然后以及还有性质，每一行单调不增，且相邻两者变化量不超过 $1$，即最大的行大小往下每种行大小都存在。

然后我们就可以考虑每一种大小的行有多少种，对这个东西做一个类似完全背包的东西即可，复杂度 $\mathcal O(n\sqrt n)$。

然后我们考虑知道了 $g$ 如何计算 $f_i$，依然考虑容斥，用能凑出 $[1,i]$ 的总方案数，减去之前就已经不满足条件过的方案数，即：

$$f_i=g_i-\sum_{j=1}^{i-1}f_jval(j,i)$$

然后我们考虑 $val(j,i)$ 是什么，很明显就是在 $[j+2,i]$ 中，凑出 $i-j$ 的方案数。

我们设后面减去的一坨为 $h_i$，首先我们考虑 $h,g$ 的不同，我们的初值从 $1$，变成了 $f_j$，以及我们假设选了 $c$ 个数，后者得到的权值加上了 $j+c(j+2)$，也就是赋值初值的部分变成了 $f_j\to h_{j+c(j+2)}$。

不难知道 $c$ 还是 $O(\sqrt n)$ 级别的，然后我们可以背包转移，但是现在的问题变成了我们背包转移的时候实际上同时转移了 $[1,n]$ 的每个 $f_i$，但是我们要算出 $f_j$ 后才能给 $h$ 赋初值，然后就寄了。

一个观察是由于 $c\ge 1,j+(j+2)\ge 2j$，所以我们可以每次先算出 $[1,\frac n 2]$ 中的每个 $f_i$，然后来计算 $[\frac n 2 +1,n]$ 中的每个 $f$。

复杂度是 $T(n)=\mathcal O(n\sqrt n)+T(\frac n2)=\mathcal O(n\sqrt n)$ 的。

放个代码：

Code

##include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=5e5+5;
int lim,n,H,p2[N],t[N],f[N];
inline void add(int &a,int b){if((a+=b)>=H) a-=H;}
inline void solve(int n){
	if(n<=1) return;
	solve(n>>1),lim=sqrt(2*n);
	for(int i=0;i<=n;++i) t[i]=0;
	for(int i=lim;i;--i){
		for(int j=n;j>=i;--j) t[j]=t[j-i];
		for(int j=0;j+(j+2)*i<=n;++j) add(t[j+(j+2)*i],f[j]);
		for(int j=i;j<=n;++j) add(t[j],t[j-i]);
	}
	for(int i=(n>>1)+1;i<=n;++i) add(f[i],H-t[i]);
}
signed main(){
	cin>>n>>H,p2[0]=1;
	for(int i=1;i<N;++i) p2[i]=p2[i-1]*2%H;
	lim=sqrt(2*n),f[0]=1;
	for(int i=lim;i;--i){
		for(int j=n;j>i;--j) f[j]=f[j-i];
		for(int j=i;j<=n;++j) add(f[j],f[j-i]);
	}
	solve(n);
	int ans=p2[n];
	for(int i=1;i<=n;++i) ans+=H-f[i-1]*p2[n-i]%H;
	cout<<ans%H<<"\n";
}

AT_agc029_f [AGC029F] Construction of a tree

考察无解条件，如果对于 ${E_1,E_2,\ldots E_{n-1}}$ 的一个子集 $S$，能连通的所有点大小 $|f(S)|\le |S|$ 就寄了，因为一定有环，所以 $|f(S)|>|S|$。

我们先找一个二分图最大匹配，如果不是 $n-1$ 无解。

然后找到没有匹配的点 $r$，对于他找到他连着另外一段没有访问过的边 $i$ 及其匹配的点 $u$，连接 $(r,u)$。

如何证明这个不会把有解变成无解：直接考虑我们右边没有遍历到的集合 $S$，由于我们遍历到的点数比边数大 $1$，而且 $S$ 连接的点 $f(S)$ 也一定没有遍历过，所以 $|f(S)|\le |S|$，所以本身就是无解的。

然后就做完了。

AT_agc024_f [AGC024F] Simple Subsequence Problem

建出子序列自动机，然后构造的状态 $f_{S,T}$ 是已经匹配了 $S$ 在自动机上还剩下 $T$，由于 $|S|+|T|\le n$，所以状态数是 $O(n2^n)$，写法需要精细实现。

放个贺的代码：

Code

#include<bits/stdc++.h>
using namespace std;
const int N=21;
int n,K,ans,hb[1<<N],tr[1<<N][2],f[N][1<<N];
char c;
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>K;
	for(int i=0;i<=n;++i)
		for(int x=0;x<(1<<i);++x) cin>>c,f[i][(1<<i)|x]=c-'0';
	hb[0]=-1;
	for(int S=1;S<(2<<n);++S) hb[S]=hb[S>>1]+1;
	for(int S=2;S<(2<<n);++S){
		if(S>>(hb[S]-1)&1) tr[S][0]=tr[tr[S][1]=S^(1<<hb[S])][0];
		else tr[S][1]=tr[tr[S][0]=S^(3<<(hb[S]-1))][1];
	}
	for(int i=n;i;--i)
		for(int A=1<<i;A<(2<<n);++A)
			if(f[i][A]){
				int _=A>>i,B=(A&((1<<i)-1))|1<<i;
				if(tr[B][0]) f[hb[tr[B][0]]][((_<<1)<<hb[tr[B][0]])^tr[B][0]^(1<<hb[tr[B][0]])]+=f[i][A];
				if(tr[B][1]) f[hb[tr[B][1]]][((_<<1|1)<<hb[tr[B][1]])^tr[B][1]^(1<<hb[tr[B][1]])]+=f[i][A];
				f[0][_]+=f[i][A];
			}
	ans=1;
	for(int S=2;S<(2<<n);++S) if(f[0][S]>=K&&hb[S]>hb[ans]) ans=S;
	int j=n;
	while(~ans>>j&1) --j;
	while(j--) cout<<(ans>>j&1);
}

CF794G Replace All

*3400 uob 直接切了，有点牛了。

首先考虑没有 ? 的情况。

如果 A=B，则答案就是 $(\sum_{i=1}^n2^i)^2$。

否则我们考虑去掉前缀相同的 $AB$，我们现在两个串分别是 $A,B$ 开头，设 $|S|>|T|$，则我们可以令 $S=T+S'$，然后两者可以去掉相同的前缀 $T$，然后如果 B 后面还是 B，则我们会 $S'$ 再次减去一个 $T$，否则我们不难知道 $S'$ 是 $T+S'$ 的前缀，然后就是若干个 $T$ 的循环，我们发现这个过程类似辗转相除，最后我们得到的长度就是 $\gcd(|S|,|T|)$。

我们设上下差了 $a$ 个 $A$，$b$ 个 $B$，则 $a|A|=b|B|$。

• $a=b=0$，枚举 $|A|,|B|$，答案是 $\sum_{i=1}^n\sum_{j=1}^n 2^{\gcd(i,j)}$。
• $a,b>0$，先约分成 $a',b'$，所以 $\frac {|A|}{\gcd(|A|,|B|)}=b'\frac {|B|}{\gcd(|A|,|B|)}=a'$，然后 $\gcd$ 不超过 $lim=\frac {n}{\max(a',b')}$，答案是 $\sum_{i=1}^{lim}2^i$。

然后我们设这个答案是 $f(a,b)$。

设本来差了 $a,b$ 个 $A,B$，两个串分别有 $ca,cb$ 个 ？则：

$$\begin{aligned} Ans&=\sum_{i=0}^{ca}\sum_{j=0}^{cb}\binom {ca}i\binom {cb}jf(a+i-j,b+(ca-i)-(cb-j))\\ &=\sum_{t=-cb}^{ca}f(a+t,b+ca-cb-t)\sum_{j=0}^{cb}\binom {cb}j\binom {ca}{ca-t-j}\\ &=\sum_{t=-cb}^{ca}f(a+t,b+ca-cb-t)\binom {ca+cb}{ca-t} \end{aligned}$$

然后就做完了。

CF2003F Turtle and Three Sequences

似乎叫 color-coding，我记得 CSP2022 的时候就有老哥 T1 用这个方法过了，给了我巨大震撼。

由于有互不相同的限制，考虑对于每个点赋值一种 $1\sim m$ 的颜色，然后我们状压选了哪些，做 $T$ 次，树状数组优化，复杂度 $O(Tn2^m\log n)$。

考虑正确率，由于只要最后成为答案的 $m$ 个数颜色不同就成功，所以一次的正确率是 $\frac {m!}{m^m}$，正确率大概是 $1-(1-\frac {m!}{m^m})^T$。

还有一种方法是不枚举子集，分配颜色的同时钦定顺序，则复杂度为 $O(Tnm\log n)$，正确率变成 $1-(1-\frac 1 {m!})^T$。

CF1951H Thanos Snap

考虑二分，然后我们设 $f_x$ 表示在操作 $x$ 子树前至少要提前操作多少次才合法。

首先是假设子树内有 $x$ 个 $1$，$f_x=\max(0,sz-x)$。

然后就是 $f_{x}=f_{ls}+f_{rs}-1$，这三种情况。

CF1305F Kuroni and the Punishment

首先不难发现答案不超过 $n$，所以有 $>=\frac n 2$ 个点是 $-1,1,+1$ 三种情况，随机 $T$ 次，每次找到一个 $a_x$，找出 $a_x-1,a_x,a_x+1$ 的质因数，扔进一个 set 里，最后对于 set 里面的每个数计算答案即可。

CF1951G Clacking Balls

停时板子题，首先考虑如何刻画这一坨，因为这个直接维护下标比较抽象，我们考虑维护相邻两个的位置差 $d$，然后由于 $d=0$ 时删除不好计算，我们直接令 $f(0)=0$ 即可。

然后我们考虑计算这个，设当前有 $t$ 个点：

$$\begin{aligned} \sum_{i=1}^tf(d_i)&=1+\frac 1 n\sum_{i=1}^t(f(d_i-1)+f(d_{i+1}+1)+\sum_{j\not= i}f(d_j))\\ 2\sum_{i=1}^tf(d_i)&=n+\sum_{i=1}^tf(d_i+1)+f(d_i-1)\\ f(x+1)-f(x)&=g(x)\\ \sum_{i=1}^tg(d_i-1)&=n+\sum_{i=1}^tg(d_i)\\ g(x)-g(x-1)&=h(x)\\ \sum_{i=1}^th(d_i)&=-n\\ \end{aligned}$$

由于 $\sum d_i=m$，所以我们令 $h(x)=-\frac n m x$ 即可。

我们可以令 $g(0)=0$，此时，此时 $g(x)=-\frac n m \binom {x+1}2$。

由于 $f(0)=0$，所以 $f(x)=-\frac n m \binom {x+1}3$，然后就做完了。

CF566C Logistical Questions

首先我们不难发现这玩意是凸的。

所以第一个做法就是每次找到代价最小的点，走过去。

这样复杂度是 $O(n^2)$ 的，考虑优化。

由于代价不好计算，但是我们只需要找到代价减少的那一个，我们考虑对于代价求导，算出每个节点对应的代价变化率，而这个变化率是可以简单判断的，而且计算变化率只需要考虑子树内部的点即可，此时走一步就是 $O(n)$ 的了。

然后我们要减少步数，点分治即可。

CF1221G Graph And Numbers

$2^3$ 容斥，然后有一个独立集计数的部分，暴搜+记忆化是 $O(2^\frac n 2)$ 的。

CF325E The Red Button

神秘 *2800 的构造题，hanghang 直接 2 min 切了。

首先考察对于 $n$ 为奇数的情况，我们不难知道 $0$ 入点为 $0,\frac {n-1}2$，$n-1$ 入点为 $\frac {n-1}2,n-1$，显然寄了。

然后对于 $n$ 为偶数的情况，我们可以知道 $a$ 和 $a+\frac n2$ 的出点情况是相同的，都是 $2a,2a+1$，且 $2a,2a+1$ 的入点只有 $a,a+\frac n 2$，我们设这四个点是 $A,B,C,D,A\not= B,C\not= D$。

那么我们只有 $A\to C,B\to D$ 和 $A\to D,B\to C$ 两种情况。

然后我们随意找一种方法连边，则会连出若干有向环，然后有一个结论

• 如果存在 $>1$ 个环，则一定存在一个组合分开在两个环内。

反证法。若所有组合在同一环里，则组合为 $A,B$ 对应的 $C,D$ 也在同一个环里，进一步得到任意 $x\in [0,n-1]$ 其与 $2x,2x+1$ 在同一个环里，由二进制拆分，我们可以从 $0$ 开始走到任意点，所以所有点在同一个环里，矛盾，原命题成立。

CF582D Number of Binominal Coefficients

考虑库莫尔定理，$v_p(\binom {a+b} a)$ 恰好为在 $p$ 进制下进位的次数，然后简单从高到滴数位 dp 即可，$f_{i,j,0/1,0/1}$ 表示考虑到第 $i$ 位，进位 $j$ 次，是否达到上界，下一位是否给这一位进位。

CF1569F Palindromic Hamiltonian Path

暴搜出匹配长什么样，这个是 $\frac 1 {(n/2)!}\binom n {n/2}$，然后枚举全排列判断行不行，暴搜每个串的形态，这个是贝尔数。

CF193D Two Segments

从值域上考虑，计算对于对于当前的 $r$，每个 $l$ 形成的连续段数量，线段树维护。

CF1625E2 Cats on the Upgrade (hard version)

建出括号序列树，然后就简单 DS 维护了。

CF2021E3 Digital Village (Extreme Version)

首先建出 Kruskal 重构树，然后我们考虑对于已经在若干个点建出了服务器后的代价，首先把每个服务器及其祖先的 $vis$ 置为 $1$，然后对于每个关键点找到最深的 $vis$ 为 $1$ 的祖先 $x$，则答案就是 $\sum val_x$。

这个最深的限制不香，我们拆成 $(val_x-val_{f_x})+(val_{f_x}-val_{f_{f_x}})+\ldots$，则此时设每个点内部的关键点个数是 $g_x$，我们知道代价是 $\sum g_x(val_x-val_{f_x})[vis_x=1]$。

然后我们每次找到代价最小的一个叶子即可。

更好的做法是建立 Kruskal 重构树的时候直接维护代价最小的叶子，然后建出一个树形结构，然后每次堆找到最小代价的即可。

LOJ547 「LibreOJ β Round #7」匹配字符串

首先 dp 是简单的，设 $f_i$ 表示考虑前 $i$ 个位置合法 $a_i$ 为 $0$ 的方案数。

$$f_n=\sum_{i=n-m}^{n-1}f_i$$

然后我们做一下前缀和，方程变成：

$$\begin{aligned} s_n=2s_{n-1}-s_{n-m-1} \end{aligned}$$

首先如果 $m$ 比较小，我们直接启动线性递推，$O(m\log m\log n)$。

否则我们考虑这个东西的组合意义：

要么从 $n$ 走到 $n+1$，权值乘上 $2$，也可以 $n$ 走到 $n+m+1$，权值乘上 $-1$。

然后枚举走了多少 $m+1$，则：

$$s_n=\sum_{i=0}^{\lfloor \frac n {m+1}\rfloor}(-1)^i2^{n-(m+1)i}\binom {n-mi}i$$

这个是 $O(\frac n m)$ 的，拼起来就是 $O(\sqrt n\log n)$ 的，但是模数 $65537=2^{16}+1$，所以似乎 NTT 长度不能超过 $2^{16}$.

---

11.11-11.17

CF798E Mike and code of a permutation

不难发现我们根据这个关系可以建出一个 DAG，然后优化建图是简单的。

CF436E Cardboard Box

经典反悔贪心题目，我们考虑我们的增加一颗星的决策有哪些。

• 增加一个 $a_i$。
• 在 $i$ 状态为 $1$ 的情况下选择一个 $b_i-a_i$。
• 在 $i,j$ 状态为 $0,1$ 的时候变成 $2,0$，代价为 $b_i-a_j$
• 在 $i,j$ 状态为 $0,2$ 时变成 $2,1$，代价为 $b_i-(b_j-a_j)$

然后用五个堆维护对应方案即可。

Code

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=3e5+5;
int n,k,a[N],b[N],ans,vis[N];
struct Node{int val,id;};
inline bool operator<(const Node a,const Node b){return a.val>b.val;}
struct queue{
	int op;
	priority_queue<Node>Q;
	inline void up(){while(Q.size()&&vis[Q.top().id]!=op) Q.pop();}
	inline int size(){return up(),Q.size();}
	inline Node top(){return up(),Q.top();}
	inline void push(Node x){Q.push(x);}
}q1,q2,q3,q4,q5;
/*
vis=0 ax
vis=0 bx
vis=1 bx-ax
vis=1 -ax
vis=2 -(bx-ax)
*/
inline void push0(int x){
	vis[x]=0,q1.push({a[x],x}),q2.push({b[x],x});
}
inline void push1(int x){
	vis[x]=1,q3.push({b[x]-a[x],x}),q4.push({-a[x],x});
}
inline void push2(int x){
	vis[x]=2,q5.push({-(b[x]-a[x]),x});
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>k;
	for(int i=1;i<=n;++i) cin>>a[i]>>b[i];
	q1.op=q2.op=0,q3.op=q4.op=1,q5.op=2;
	for(int i=1;i<=n;++i) push0(i);
	for(int i=1;i<=k;++i){
		int res=1e9+7,op=0,p=0,q=0;
		if(q1.size()&&q1.top().val<res) res=q1.top().val,p=q1.top().id,op=1;
		if(q3.size()&&q3.top().val<res) res=q3.top().val,p=q3.top().id,op=2;
		if(q2.size()&&q4.size()&&(q2.top().val+q4.top().val)<res) res=q2.top().val+q4.top().val,p=q2.top().id,q=q4.top().id,op=3;
		if(q2.size()&&q5.size()&&(q2.top().val+q5.top().val)<res) res=q2.top().val+q5.top().val,p=q2.top().id,q=q5.top().id,op=4;
		ans+=res;
		if(op==1) push1(p);
		if(op==2) push2(p);
		if(op==3) push2(p),push0(q);
		if(op==4) push2(p),push1(q);
	}
	cout<<ans<<"\n";
	for(int i=1;i<=n;++i) cout<<vis[i];
}

CF1474E What Is It?

简单构造题，首先画出 $i\to p_i$，不难发现每次是增加 $(i-p_i)^2$，然后删除 $p_i$，所以不难构造出 $1,n-1,n-2,\ldots \frac n 2,n,2,3,4,5\ldots \frac n 2$。

这样答案是上界，注意特判 $n=2,3$。

CF1540D Inverse Inversions

首先不难知道如果我们设 $a_x=x-b_x$，则表示 $x$ 在前 $i$ 个数中的相对大小，所以我们初始设 $val=a_x$，然后扫描 $[l,r]$，如果 $val\ge a_i$ 就让 $val+1$。

我们不难知道这个东西可以合并，然后一个长度为 len 的区间合并起来是一个大小为 $O(len)$ 的分段函数，然后我们就可以直接分块维护即可。

我用了种奇怪的写法，复杂度 $O(n\log n+Q(B+\frac {n}B\log n))=O(n\log n+Q\sqrt{n\log n})$。

CF1827C Palindrome Partition

首先我们维护 $i$ 表示以 $i$ 为结尾的好的串的个数，然后考虑如果满足 $[d_i,i]$ 是一个偶回文子串且 $d_i$ 最大，不难知道 $f_{i}=f_{d_i-1}+1$。

然后我们只需要对于每一个 $i$ 找出一个 $d_i$ 即可，直接找到 $d_i$ 可能不好找，我们可以先找到回文中心，然后再给他维护到的区间取 $\max$ 即可。

CF2025G Variable Damage

首先不难知道答案是：

$$\sum {a_i}+\min(a_i,b_i)$$

所以一定是从大到小排序后依次配对，先算上前面的 $a_i$，我们只计算后面的 $\min$ 部分。

如果把人看成 $1$，装备看成 $-1$。

我们考察一个人的贡献什么时候能被用上，不难知道此时前缀和一定 $< 0$。

我们考察一个装备的贡献什么时候能被用上，不难知道此时前缀和一定 $> 0$。

然后我们考虑这个区间怎么合并，不难发现一个区间的取值还是 $O(\sqrt n)$ 段的，然后分块维护即可。

$O(n+Q\sqrt n)$。

P8497 [NOI2022] 移除石子

首先我们考虑对于一个确定的 $a_i$ 怎么做，我们首先找点性质：

• 不会存在长度超过 $5$ 的区间，否则我们可以拆成若干个 $3$+一个长度不超过 $5$ 的区间。
• 每种相同的区间不会超过一个，否则我们可以直接换成 $1$ 操作。

然后恰好非常难受，我们考虑转成至多，我们考虑中间有哪些不同之处。

$k=1$ 的时候，讨论不加入时便有解的情况：

• 出现 $1$ 操作，把这个石子扔到一操作内即可。
• 有长度 $>3$ 的二操作，把边上的去掉，加入石子，加入一操作即可。
• 有二操作且 $n>3$，拓展此操作。

$k>1$ 时分类讨论：

• $k=0$ 有解，用一次一操作删了剩下的。
• $k=1$ 无解，由于不可能加入 $k-1$ 个石子后从有解变成无解，所以一定无解。

综上，只有不存在操作即全是 $0$ 或者 $a=\{1,1,1\}$ 时不行，特判即可。

现在我们只需要计算最少需要的石子个数即可，考虑 dp：

设 $f_{i,j,k}$ 表示考虑 $1\sim i-1$，考虑了 $j$ 个至少到 $i$，$k$ 个至少到 $i+1$，转移时枚举 $l$ 个从 $i$ 开始，然后转移代价是好计算的，这样我们就可以得到 $40pts$ 的暴力 dp：

Code

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e3+5,H=1e9+7;
int T,n,K,l[N],r[N],ans;
inline void cmin(int &a,int b){a=min(a,b);}
namespace Sub{
	int a[N],f[N][7][4];
	inline int solve(){
		if(K==1){
			if(accumulate(a+1,a+n+1,0)==0) return 0;
			if(n==3&&a[1]==1&&a[2]==1&&a[3]==1) return 0;
		}
		memset(f,0x3f,sizeof f),f[1][0][0]=0;
		for(int i=1;i<=n;++i)
			for(int j=0;j<=6;++j)
				for(int k=0;k<=3;++k)
					if(f[i][j][k]<=K){
						for(int l=0;l<=3;++l){
							int u=a[i]-j-k-l,v=u<0?-u:u==1?1:0;
							for(int p=k;p<=j+k&&p<=6;++p) cmin(f[i+1][p][l],f[i][j][k]+v);
						}
					}
		return f[n+1][0][0]<=K;
	}
}
inline void dfs(int x){
	if(x>n) return ans+=Sub::solve(),void();
	for(int i=l[x];i<=r[x];++i) Sub::a[x]=i,dfs(x+1);
}
inline void solve(){
	cin>>n>>K,ans=0;
	for(int i=1;i<=n;++i) cin>>l[i]>>r[i];
	dfs(1),cout<<ans<<"\n";
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>T;
	while(T--) solve();
}

考虑怎么做到更好，考虑 dp 套 dp，然后暴搜出来状态只有 $8000+$ 个，然后就做完了。

Code

#include<bits/stdc++.h>
#define int long long
#define Vec vector<int>
using namespace std;
const int N=1e3+5,M=1e4+5,H=1e9+7;
int T,n,K,l[N],r[N],ans;
int trans[M][9],f[2][M],tot;
map<Vec,int>mp;
inline void cmin(int &a,int b){a=min(a,b);}
inline void add(int &a,int b){if((a+=b)>=H) a-=H;}
inline int dfs(Vec a){
	if(mp.find(a)!=mp.end()) return mp[a];
	int id=mp[a]=++tot;
	for(int t=0;t<=8;++t){
		vector<int>cur(9,101);
		for(int j=0;j<3;++j)
			for(int k=0;k<3;++k)
				if(a[j*3+k]<=100) for(int l=0;l<3;++l){
					int u=t-j-k-l,v=u<0?-u:u==1?1:0;
					for(int p=k;p<=j+k&&p<3;++p) cmin(cur[p*3+l],a[j*3+k]+v);
				}
		trans[id][t]=dfs(cur);
	}
	return id;
}
inline int delta(){
	if(K==1) return (count(l+1,l+n+1,0)==n)+(n==3&&l[1]<=1&&l[2]<=1&&l[3]<=1&&r[1]>=1&&r[2]>=1&&r[3]>=1);
	return 0;
}
inline void solve(){
	cin>>n>>K;
	for(int i=1;i<=n;++i) cin>>l[i]>>r[i];
	ans=(H-delta())%H,memset(f[1],0,sizeof f[1]),f[1][1]=1;
	for(int i=1;i<=n;++i){
		memcpy(f[0],f[1],sizeof f[0]),memset(f[1],0,sizeof f[1]);
		for(int t=0;t<=8;++t){
			int val=0;
			if(t<8) val=(t>=l[i]&&t<=r[i]);
			else if(r[i]>=8) val=r[i]-max(8ll,l[i])+1;
			if(val) for(int j=1;j<=tot;++j) if(f[0][j]) add(f[1][trans[j][t]],f[0][j]*val%H);
		}
	}
	for(auto i:mp) if(i.first[0]<=K) add(ans,f[1][i.second]);
	cout<<ans<<"\n";
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	dfs((Vec){0,101,101,101,101,101,101,101,101});
	cin>>T;
	while(T--) solve();
}

P4484 [BJWC2018] 最长上升子序列

考虑双杨表和排列的双射，然后考虑最长上升子序列的长度就是杨表第一行的长度，我们暴搜杨表形态，这个是拆分数的，然后用钩长公式算出杨表的方案数，最后求和即可。

复杂度 $O(np(n))$。

P3774 [CTSC2017] 最长上升子序列

由于 Dilworth 定理，我们考虑如果不存在长度为 $k+1$ 的上升子序列，则我们的小大就是前 $k$ 列的大小和。

然后我们可以暴力维护杨表了，复杂度 $O(n^2\log n)$，可以通过 $95pts$。

我们考虑如果一个 $(a,b)$ 存在，则必须满足 $a\times b\le n$，所以 $a,b$ 里必须有一个 $\le \lceil \sqrt \rceil$，所以实际上我们维护一个普通杨表和一个转置杨表的前 $O(\sqrt n)$ 行，即可得到所有的信息。

考虑如何计算答案。

如果 $k$ 不超过 $B$，直接统计转置杨表的前 $k$ 行。
否则我们先统计杨表前 $B$ 行，然后剩下的都在转移杨表的前 $B$ 行内，直接统计即可。

AT_agc018_c [AGC018C] Coins

同样反悔贪心，找到 $6$ 种反悔决策即可。

P9870 [NOIP2023] 双序列拓展

暴力 dp 是简单的，然后我们可以把这个过程变成在二维平面上走，然后我们直接考虑一下最值的位置，然后分治求解即可。

P7116 [NOIP2020] 微信步数

把计算的东西变成每一个时刻还有多少点存在。

首先暴力算出第一组的答案，然后每一组被删除多少点可以算出来，发现每一个维度相乘是一个 $O(k)$ 次多项式，线性拉插即可。

牛顿插值忘完了怎么办，爆，重新推了一遍：

$$\begin{aligned} f(x)&=\sum_{i=0}^n\binom {x-x_0}i\Delta^if(x_0)\\ 取 x_0&=0\\ &=\sum_{i=0}^n\binom x i\sum_{k=0}^i\binom i k(-1)^{i-k}f(k)\\ &=\sum_{k=0}^nf(k)\sum_{i=k}^n\binom i k\binom x i(-1)^{i-k}\\ &=\sum_{k=0}^nf(k)\binom x k\sum_{i=k}^n\binom {x-k}{i-k}(-1)^{i-k}\\ &=\sum_{k=0}^nf(k)\binom x k\sum_{i=k}^n\binom {i-x-1}{k-x-1}\\ &=\sum_{k=0}^nf(k)\binom x k\binom {n-x}{k-x}\\ &=\sum_{k=0}^nf(k)\binom x k(-1)^{n-k}\binom {x-k-1}{n-k}\\ f(T)&=\sum_{i=0}^nf(i)(-1)^{n-i}\binom T i\binom {T-i-1}{n-i}\\ &=\sum_{i=0}^nf(i)(-1)^{n-i}\frac {T^{\underline {n+1}}}{(T-i)\times i!\times (n-i)!} \end{aligned}$$

P10304 [THUWC 2020] 道路修建

对于一个点 $x$，记录一个 $c_x$ 表示如果删除的祖先深度 $\ge c_x$ 则存在 $1$ 条 $1\to x$ 的路径，知道 $c_x$ 后求解答案是简单的，考虑如何求解 $c_x$。

首先找到 dfs 生成树后，按逆拓扑序维护每条非树边，然后对于一条 $u\to v$，拿出 $u\to lca(u,v)$ 上的最小值来更新 $c_v$。

P8819 [CSP-S 2022] 星战

经典哈希题。

CF1824D LuoTianyi and the Function

简单扫描线+历史版本和。

首先我们把一条路径的代价变成 $\sum e_i-2w$，这样的话，对于两种情况，收益都是 $\frac 1 2(c_{u1,v1}+c_{u2,v2}+dis(u1,u2)+dis(v1,v2))$。

然后我们枚举 $t=lca(u1,u2)$，则收益变成了：

$$\frac 1 2 (c_{u1,v1}+c_{u2,v2}+dis_{u1}+dis_{v1}-2dis_t+dis(v1,v2))$$

然后这个就是简单的树上直径维护了。

所以我们对于每个 $(u,v)$ 路径，在 $u$ 上添加，在 $u\to lca(u,v)$ 路径的倒数第二个点删除，然后线段树合并维护即可。

CF1137F Matches Are Not a Child's Play

胡了一个巨大复杂的做法，看起来代码不会少于 $5k$，然后观察题解有简单做法。

首先我们以最大值为根，因为他一定是最后一个被删除的，维护每个点子树内的最大值 $mx_x$，考虑询问 $x$ 的时候答案是怎样的。

我们首先考虑如果存在 $y$ 满足 $mx_y<mx_x$，那么 $y$ 一定会在 $x$ 之前删除，$mx_y>mx_x$，则 $y$ 一定会在 $x$ 后删除，剩下是 $mx_y=mx_x$ 的情况，不难发现此时比 $x$ 先删除的就是 $x\to mx_x$ 这一条路径上的点，然后就做完了。

然后链推平可以 ODT 或者 LCT 即可 + BIT 维护即可。

我胡的做法是考虑以询问的 $x$ 为根，然后考察最大值的位置，找到删除了最大值所在子树的最大值，然后首先除了最大值所在的子树都会被选，然后最大值的子树内相当于如果子树最大值小于某个数就会被选，如果最大值所在子树在本来以 $1$ 为根时 $x$ 的子树内，这个是好计算的。

否则我们考虑除了 $x\to 1$ 的链，剩下的都是本来就是子树的可以直接维护,$x\to 1$ 的链有单调性，可以二分维护。

然后巨大难写，无法可想。

实现了题解做法：

Code

#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int N=4e5+5;
int n,q,cnt,pos[N],a[N],mx[N];
int dfn[N],dep[N],f[N],sz[N],son[N],top[N],dn;
vector<int>G[N];
struct node{
	int l,r,v;
	inline node(int _l=0,int _r=0,int _v=0){l=_l,r=_r,v=_v;}
	inline bool operator<(const node a)const{
		return l<a.l;
	}
};
set<node>S;
inline void dfs1(int x,int fa){
	sz[x]=1,dep[x]=dep[f[x]=fa]+1,mx[x]=x;
	for(auto v:G[x]) if(v!=fa) 
		dfs1(v,x),sz[x]+=sz[v],mx[x]=max(mx[x],mx[v]),
		son[x]=sz[v]>sz[son[x]]?v:son[x];
}
inline void dfs2(int x,int tp){
	top[x]=tp,dfn[x]=++dn;
	if(son[x]) dfs2(son[x],tp);
	for(auto v:G[x]) if(v!=f[x]&&v!=son[x]) dfs2(v,v);
}
inline int lca(int u,int v){
	while(top[u]!=top[v])
		if(dep[top[u]]>=dep[top[v]]) u=f[top[u]];
		else v=f[top[v]];
	return dep[u]<dep[v]?u:v;
}
inline int dist(int a,int b){return dep[a]+dep[b]-2*dep[lca(a,b)];}
namespace BIT{
	int c[N];
	inline void add(int x,int v){
		for(;x<=n+q;x+=x&-x) c[x]+=v;
	}
	inline int ask(int x){
		int ans=0;
		for(;x;x-=x&-x) ans+=c[x];
		return ans;
	}
}
#define iter set<node>::iterator
inline iter split(int x){
	auto it=S.lower_bound(node(x));
	if(it->l==x) return it;
	node now=*(--it);
	S.erase(it),S.insert(node(now.l,x-1,now.v));
	return S.insert(node(x,now.r,now.v)).first;
}
inline void assign(int l,int r,int v){
	auto ed=split(r+1),st=split(l);
	for(auto it=st;it!=ed;++it) BIT::add(it->v,-(it->r-it->l+1));
	S.erase(st,ed),S.insert(node(l,r,v)),BIT::add(v,r-l+1);
}
inline void upd(int x,int y,int val){
	while(top[x]!=top[y])
		if(dep[top[x]]>=dep[top[y]]) assign(dfn[top[x]],dfn[x],val),x=f[top[x]];
		else assign(dfn[top[y]],dfn[y],val),y=f[top[y]];
	if(dep[x]<=dep[y]) assign(dfn[x],dfn[y],val);
	else assign(dfn[y],dfn[x],val);
}
inline void change(int x){
	pos[a[x]=++cnt]=x,upd(pos[cnt-1],x,cnt-1),assign(dfn[x],dfn[x],cnt);
}
inline int ask(int x){
	auto it=--S.upper_bound(node(dfn[x]));
	return BIT::ask((it->v)-1)+dist(pos[it->v],x)+1;
}
char opt[20];
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>q;
	for(int i=1;i<=n;++i) a[i]=pos[i]=i;
	for(int u,v,i=1;i<n;++i) cin>>u>>v,G[u].pb(v),G[v].pb(u);
	dfs1(n,0),dfs2(n,n),S.insert(node(n+1,n+1,0)),cnt=n;
	for(int i=1;i<=n;++i) BIT::add(mx[i],1),S.insert(node(dfn[i],dfn[i],mx[i]));
	for(int i=1,u,v;i<=q;++i){
		cin>>opt>>u;
		if(opt[0]=='u') change(u);
		else if(opt[0]=='w') cout<<ask(u)<<"\n";
		else cin>>v,cout<<(ask(u)<ask(v)?u:v)<<"\n";
	}
}

CF799F Beautiful fountains rows

糊了个跟 std 相同的扫描线做法，然后一看题解全是哈希，震撼人心。

你对于每一行，把这一行的 $r$ 标成 $0$，然后我们得到：

• $[l,r]$ 满足条件等价于 $[l,r-1]$ 里面的 $1$ 为偶数。

然后我们直接哈希即可。

CF1286D LCC

感觉，水平不如 7 月份了。

首先只有 $2(n-1)$ 种可能成为答案，然后从小到大扫描答案，然后我们考虑 dp 出概率，不难发现我们每次就是 ban 掉一个形如 $S_x=A 且 S_{x+1}=B$ 的情况，这个我们可以 ban 完直接 ddp 即可。

---

11.18-11.24

AT_arc187_d [ARC187D] Many Easy Optimizations

考察枚举最小值之后怎么维护？贪心选后继即可。

我们用线段树同时维护 $O(n)$ 个最小值即可。

AT_agc016_d [AGC016D] XOR Replace

不难发现就是拿异或和与一个点交换，然后贪心换换即可。

AT_pakencamp_2018_day2_g グランド・グラフ　(Grand Graph)

首先我们知道 $m-n\le 2$，所以我们可以考虑广义串并联图，给图缩完之后我们发现此时点数很小，然后我们可以暴力 Bell 数划分或者直接状压 dp 即可。

P5295 [北京省选集训2019] 图的难题

Nash-William 定理：一个图可以划分成 $k$ 个森林的条件是，对于所有导出子图，满足 $|E|\le k(|V|-1)$，即 $|E|-k|V|\le -k$。

所以我们只需要求 $|E|-k|V|$ 的最大值即可，可以使用最大权闭合子图完成。

但是不难发现，我们 $E,V$ 都是空集的时候，此时的权值已经不满足条件，所以我们每次需要强行钦定一个点必须选，然后退流即可。

P11197 [COTS 2021] 赛狗游戏 Tiket

首先设 $i$ 在三个序列中的下标分别是 $a_i,b_i,c_j$，那么实际上我们就计数有多少个 $(i,j)$ 满足：

$$a_i<a_j\and b_i<b_j\and c_i<c_j$$

首先可以三维偏序，但是有单 $\log$ 做法。

考虑计算出三种情况的二维偏序个数。

不难发现此时每个三维偏序被算了 $3$ 次，二位偏序被算了 $2$ 次。

而三维偏序数量等于零维偏序数量，二维数量等于一维数量，而总数是 $n(n-1)$。

所以我们可以知道三维偏序和二维偏序的数量和为 $\frac {n(n-1)}{2}$，用三种情况的和减去这个再除以 $2$ 就得到答案。

P5100 [JOI 2017 Final] 足球

不难知道每次球转走之后都是本来最近的球员来接球。

然后简单最短路题。

P7407 [JOI 2021 Final] ロボット (Robot)

比较困难的最短路题。

首先我们不难知道，因为颜色有 $m$ 种，所以我们每次改变颜色可以变成一个从来没有出现过的，这样不会对后面造成影响。

我们考虑在某个点有什么决策，改变这个点同一颜色的其他出边，或者改变这一条边。

但是一个问题是如果我们有 $u\to x\to v$，但是这两条边都是颜色 $c$ 且都是改变这条边的情况下，不难发现我们只需要一条边的代价即可，而此时就寄了。

对于这种情况，我们建立虚点 $(x,c)$，然后让 $u,x,v\to (x,c)$ 连边，边权是 $0$，然后 $(x,c)\to u,v$ 权值分别是改变其他的边的代价。

不难发现此时我们就省略掉了一条边的代价，完全胜利。

P7669 [JOI2018] Commuter Pass

首先建出最短路树，然后在上面 dp 一下即可。

P3204 [HNOI2010] 公交线路

首先不难想到一个状压 dp，然后我们发现这个状态数只有 $\binom {p-1}{k-1}\le 126$，然后我们矩阵快速幂优化 dp 即可。

P3502 [POI2010] CHO-Hamsters

首先我们可以先写一个 dp，$f_{i,j}$ 表示此时出现了 $i$ 次以第 $j$ 个字符串结尾的最短长度，这个转移系数可以 hash 预处理出来， $O(n|S|)$。

然后发现这个是 $(\min,+)$ 卷积，矩阵快速幂即可。

P11291 【MX-S6-T3】「KDOI-11」简单的字符串问题 2

困难题目，不想写了。

P11292 【MX-S6-T4】「KDOI-11」彩灯晚会

感觉比 T3 简单，首先我们不难知道 $cnt^2$ 可以换成选在所有里面选两个的方案数。

然后我们考虑每两条链被计算多少次，考虑两个交集大小为 $c$，则方案数为 $k^{n-2l+c+1}$，所以我们只需要对于每个 $c$ ，计算交集大小为 $c$ 的时候的选的方案数。

刚好 $c$ 不好做，然后我们考虑钦定，然后做二项式反演。

然后我们就可以 dp 了，设 $f_{x,p,q,c}$ 表示在 DAG 上 dp 到了 $x$，两条链长度为 $p,q$，交集大小为 $c$ 的方案数。

然后我们枚举下一个点 $v$，长度 $l1,l2$，转移到 $f_{v,p+l1,q+l2,c+1}$。

需要预处理一个 $h_{x,v,len}$ 表示从 $x\to v$，长度为 $len$ 的路径数量，这个是 $O(n^3l)$ 的，然后 dp 是 $O(n^2l^5)$ 的。

有点小寄，不难发现 $l1,l2$ 由于和贡献系数无关，所以可以分开枚举，这样我们就做到了 $O(n^2l^4)$。

无法通过，这个时候这个题最神秘的一点出现了：

考虑最后如何统计答案：

$$\begin{aligned} ans&=\sum_{i=0}^nk^{n-2l+i+1}\sum_{j=i}^n(-1)^{j-i}\binom j ig_j\\ &=k^{n-2l+1}\sum_{i=0}^n\sum_{j=i}^nk^i(-1)^{j-i}\binom j ig_j\\ &=k^{n-2l+1}\sum_{i=0}^n\sum_{j=i}^nk^j(-\frac {1}k)^{j-i}\binom j ig_j\\ &=k^{n-2l+1}\sum_{j=0}^nk^jg_j\sum_{i=0}^j(-\frac {1}k)^{j-i}\binom j i\\ &=k^{n-2l+1}\sum_{j=0}^nk^jg_j(1-\frac 1 k)^j\\ &=k^{n-2l+1}\sum_{j=0}^ng_j(k-1)^j \end{aligned}$$

所以每次加入一个点相当于系数乘上一个 $k-1$，这样我们 dp 时就可不用维护 $c$ 的数量，复杂度变成 $O(n^2l^3)$，可以通过。

CF1672G Cross Xor

首先我们考虑如何 check 一个矩阵合法。

首先我们可以操作 $(a,c),(a,d),(b,c),(b,d)$ ，这样可以不改变其他点的时候翻转这四个点。

如果我们只通过这种方法，我们发现，我们可以不改变每行每列的奇偶性，如果都是偶数的话我们就可以用这个变法清空。

然后我们考虑单次操作带来的影响。

我们设每行的奇偶性是 $R_i$，每列的是 $C_j$。

首先操作一个点 $(i,j)$ 对于 $R$ 的影响。

• 如果 $c$ 是偶数，则 $R$ 全体改变。
• 否则 $R$ 除了 $R_i$ 全体改变。

然后不难猜测如果 $c$ 是偶数，则 $R$ 必须全部相同，对于 $r$ 同理。

然后我们考虑计算答案，如果都是偶数，则是 $2^{cnt}$

如果 $r$ 是偶数，则枚举 $C$ 都是啥，然后计算是简单的。

否则都是奇数的情况。

枚举 $R,C$ 的权值，我们把 ? 的 $i,j$ 连边，则我们一条边等价于可以把 $R_i,C_j$ 取反，然后我们需要每个点权值都是 $0$.

不难知道这个方案数是 $2^{m-(n-1)}$。

然后就做完了。

CF2029G Balanced Problem

首先可以把序列长度减少到 $O(V)$，然后 dp，设 $f_{i,j,k}$ 表示考虑前 $i$ 个点，前缀被操作 $j$ 次，后缀操作 $k$ 次的最大权值，然后转移简单。

我们把 $k$ 定义改成离 $v$ 还有多少，然后转移就很好了。

CF1801E Gasoline prices

一个唐氏做法就是线段树维护哈希。

实际上可以倍增并查集，然后合并次数只有 $O(n\log n)$ 次，代码还比较短。

CF1976F Remove Bridges

似乎找一找形态，然后 dfs 一遍找到若干条最长链即可。

CF1320E Treeland and Viruses

建虚树，跑 Dijkstra

CF1942G Bessie and Cards

首先我们考虑计数不合法概率，然后我们把手中的牌数看成一个折线图，然后不难发现由于计算的是概率而不是方案数，所以 $1$ 有多少张是无用的。

所以此时我们只会 $\pm 1$ ，然后我们枚举什么时候似的，方案数是一个折线容斥，然后在乘上后面部分选择的组合数和什么时候放特殊点的方案数。

最后除以总方案数就是不合法概率，然后就做完了。

CF930E Coins Exhibition

离散化后双指针优化 dp 即可。

CF568E Longest Increasing Subsequence

不是很难的 dp 题，你随便做做就好了。

CF461E Appleman and a Game

首先我们考虑二分答案，然后变成了如何 check mid 次操作得到的最小长度。

这个东西，不难发现我们每次新出现的子串确定是那么这个串的决策是确定的，然后我们直接 dp 即可。

CF1758F Decent Division

神秘构造，每次对于每个区间线段树上二分找到中间权值全都更大的下一个点即可，据称这种方法操作次数不会超过 $4n$。

CF283E Cow Tennis Tournament

首先由于完全图三元环数量为：

$$\binom n 3-\sum \binom {d_i}2$$

所以我们线段树维护每个数 $i$ 的 $d_i$ 即可。

CF875E Delivery Club

二分完倒序考虑合法区间在哪里。

CF616F Expensive Strings

建出广义 SAM，然后是板子题。

CF446C DZY Loves Fibonacci Numbers

$f_{n+m}=f_{n+1}f_m+f_nf_{m-1}$，然后线段树维护。

CF1389F Bicolored Segments

首先有一个线段树优化 dp 做法。

另一个神秘做法是，考虑原图矛盾之间连边，然后二分图。

最大独立集=n-最大匹配，然后我们考虑求解这个。

然后可以经典按 $r$ 排序后贪心。

CF772D Varying Kibibits

拆一拆式子，先高维后缀和一下，再差分一下即可。

CF763D Timofey and a flat tree

树哈希，不难发现从 $u\to v$ 只会改变 $u,v$ 两个点哈希值，然后直接维护即可。

CF842E Nikita and game

首先树直径有两端，然后新增的时候考虑放到哪一端即可。

CF1181E2 A Story of One Country (Hard)

暴力是直接枚举行/列分裂。

正解是类似于启发式分裂的同时考虑四个方向从第几个开始分裂，复杂度 $O(n\log^2 n)$。

CF1400F xrime Substrings

首先 shaber 状压是 $O(n2^s)$ 的，然后我们可以暴搜出有哪些串不能出现，然后拿去建 ACAM，一跑发现节点数只有不超过 $5000$ 个，然后直接 dp 就做完了。

CF521E Cycling City

不难发现如果有两个环边有交就赢了。

然后直接上 dfs 树，然后直接树上覆盖一下即可。

CF1215F Radio Stations

首先不难知道设 $n$ 个点表示第 $i$ 个点选/不选。

然后对于交的问题，我们设 $f_i$ 表示是否 $\le i$，然后我们也可以刻画出一个限制。

然后跑 2-sat 即可。