【AtCoder】AtCoder Grand Contest 043 解题报告（E,F或许将成为永远的坑？）
\(A\)：Range Flip Find Route（点此看题面）
大致题意： 给定一个\(n\times m\)的黑白矩阵，每次操作你可以把一个矩形内所有格子颜色取反。问至少需要多少次操作才能使得从\((1,1)\)到\((n,m)\)存在一条只往下或往右走的全由白色格子组成的路径。
动态规划
显然，我们可以发现，这操作等价于我们可以对连续行走的一段路颜色取反（这可以自己画图理解一下）。
因此我们设\(f_{i,j,0/1}\)表示当前走到\((i,j)\)，是否正在取反。考虑转移方程：
- 对于白色格子，\(f_{i,j,0}=min\{f_{i-1,j,0},f_{i,j-1,0},f_{i-1,j,1},f_{i,j-1,1}\},f_{i,j,1}=INF\)。
- 对于黑色格子，\(f_{i,j,0}=INF,f_{i,j,1}=min\{f_{i-1,j,0}+1,f_{i,j-1,0}+1,f_{i-1,j,1},f_{i,j-1,1}\}\)。
于是这道签到题就这样做完了。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100
#define INF 1e9
using namespace std;
int n,m,f[N+5][N+5][2];char s[N+5][N+5];
int main()
{
RI i,j;for(scanf("%d%d",&n,&m),i=1;i<=n;++i) scanf("%s",s[i]+1);
s[1][1]^'#'?(f[1][1][0]=0,f[1][1][1]=INF):(f[1][1][0]=INF,f[1][1][1]=1);//初始化第一格
for(i=1;i<=n;++i) f[i][0][0]=f[i][0][1]=INF;//把边界赋为INF
for(i=1;i<=m;++i) f[0][i][0]=f[0][i][1]=INF;
for(i=1;i<=n;++i) for(j=1;j<=m;++j) if(i^1||j^1)
s[i][j]^'#'?(f[i][j][0]=min(min(f[i-1][j][0],f[i][j-1][0]),min(f[i-1][j][1],f[i][j-1][1])),f[i][j][1]=INF)//对于白色格子
:(f[i][j][0]=INF,f[i][j][1]=min(min(f[i-1][j][0],f[i][j-1][0])+1,min(f[i-1][j][1],f[i][j-1][1])));//对于黑色格子
return printf("%d",min(f[n][m][0],f[n][m][1])),0;//输出答案
}
\(B\)：123 Triangle（点此看题面）
大致题意： 给定一个由\(1,2,3\)组成的数组\(a_{1\sim n}\)，定义\(x_{1,j}=a_j,x_{i,j}=|x_{i-1,j}-x_{i-1,j+1}|(1\le j\le n-i+1)\)，求\(x_{n,1}\)。
大致思路
这道题是闪指导在厕所里被灯闪了一下之后秒掉的题\(\%\%\%\)
考虑我们先求出\(x_2\)这个数组，然后就会发现，\(x_2\)中不可能存在\(3\)，而最终答案中也不可能存在\(3\)。
也就是说，接下来只有可能有\(0,1,2\)。
对于只有\(0,2\)的情况，此时我们可以把\(2\)看作\(1\)，转化为\(0,1\)的情况，最后答案乘\(2\)即可。
对于同时有\(0,1,2\)的情况，此时答案绝对不可能为\(2\)，则我们发现这样一来\(0\)和\(2\)就是等价的了，可以把\(2\)看作\(0\)，同样转化为\(0,1\)的情况。
于是，我们只要考虑\(0,1\)的情况就可以了，则此时相减取绝对值实际上就是异或操作。
我们令原本的\(n\)减\(1\)（因为我们处理的是\(x_2\)这个数组，而这个数组长度为\(n-1\)），然后就会发现第\(i\)个数（\(0\le i<n\)）对答案的贡献次数实际上就是\(C_{n-1}^{i}\)。
而既然是异或我们只要考虑其奇偶性，即模\(2\)意义下的值就可以了。
注意到由于模数是\(2\)，我们不能直接求出组合数。因此我们用卢卡斯定理，这有一个常见的套路。
因为：
所以递归下去，就相当于把\(n,m\)都转化为了二进制数。
而若二进制下存在某一位使得\(n\)这一位上为\(0\)，\(m\)这一位上为\(1\)，则最终的答案就为\(0\)，否则为\(1\)。
换言之，也就是二进制下\(n\)的每一位都要大于\(m\)的对应位，而用式子表示就是\(n\ xor\ m=n-m\)。
代入到这题就是\((n-1)\ xor\ i=(n-1)-i\)。
然后这道题就做完了。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 1000000
using namespace std;
int n,a[N+5];char s[N+5];
int main()
{
RI i;for(scanf("%d%s",&n,s),--n,i=0;i^n;++i) a[i]=abs(s[i]-s[i+1]);//将原先n减1，计算出x[2]
RI f=1;for(i=0;i^n;++i) if(a[i]==1) {f=0;break;}//f=0表示存在1，f=1表示没有1，注意这题刚好能巧妙利用f的值
for(i=0;i^n;++i) a[i]==2&&(a[i]=f);//存在1时把2视作0，没有1时把2视作1
RI ans=0;for(i=0;i^n;++i) (((n-1)^i)==(n-1)-i)&&(ans^=a[i]);//根据组合数奇偶性判断这一位上数的贡献
return printf("%d",ans*(f+1)),0;//存在1时答案乘1不变，不存在1时答案要乘上2
}
\(C\)：Giant Graph（点此看题面）
大致题意： 有三张\(n\)个点的图，分别有\(m_1,m_2,m_3\)条边。现在构造一张新图，每个点的编号用一个三元组\((x,y,z)\)表示，分别代表三张图中的点，且该点点权为\(10^{18(x+y+z)}\)。若\(x\)和\(u\)之间有边，则\((x,y,z)\)和\((u,y,z)\)之间有边，\(y,z\)两维同理。求新图的最大独立集的点权和。
贪心
这个\(10^{18(x+y+z)}\)摆在这里乍一看很吓人，但实际上却让这道题简单了许多。
为什么呢？我们发现，若\(x'+y'+z'<x+y+z\)，那么即便选择\(n^3\)个\(x'+y'+z'\)（尽管这当然是不可能的），它们的点权和也比不上选择一个\(x+y+z\)。
于是就自然而然地发现，我们每次应尽量选择\(x+y+z\)较大的点。
而且，由于连边规则要求有两维一样，因此有边相连的两个点\(x+y+z\)的值不可能相等，即同一级别的点是互不影响的。
综上所述，这道题其实是道贪心题。
博弈论
什么？这道题居然会是博弈论？
考虑到\((n,n,n)\)显然是必选的，因此我们把它设为博弈的终止态。
如果我们把这个问题看作有一个棋子，每次可以把它移向值更大的点，不能再移动就输了。那么这就相当于是一个由三堆石子构成的\(Nim\)问题。也就是说，三张图之间相互独立，我们可以分别讨论。
由于标定了边的方向，原图变成了一张\(DAG\)，而先手和后手轮流选择就恰好是一个独立集的过程。
因此，对于一个点\((x,y,z)\)若\(SG1_x\ xor\ SG2_y\ xor\ SG3_z=0\)，那么该点就可以被选择。
而求答案的时候只要枚举前两张图的\(SG\)值\(i\)和\(j\)，统计下每一张图中\(SG=k\)时\(10^{18i}\)的和\(tot_k\)，那么就可以给答案加上：\(tot1_{i}\times tot2_{j}\times tot3_{i\ xor\ j}\)。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
#define X 998244353
#define Inc(x,y) ((x+=(y))>=X&&(x-=X))
using namespace std;
int n,pw[N+5];
class FastIO
{
private:
#define FS 100000
#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
#define D isdigit(c=tc())
char c,*A,*B,FI[FS];
public:
I FastIO() {A=B=FI;}
Tp I void read(Ty& x) {x=0;W(!D);W(x=(x<<3)+(x<<1)+(c&15),D);}
}F;
class Graph//处理一张图的答案
{
private:
#define add(x,y) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y)
int m,ee,lnk[N+5],SG[N+5],vis[N+5];struct edge {int to,nxt;}e[2*N+5];
I void dfs(CI x)//搜索求出SG
{
RI i;for(i=lnk[x];i;i=e[i].nxt) x<e[i].to&&!~SG[e[i].to]&&(dfs(e[i].to),0);//处理后继状态的SG值
for(i=lnk[x];i;i=e[i].nxt) x<e[i].to&&(vis[SG[e[i].to]]=x);//标记哪些SG值出现过
for(SG[x]=0;vis[SG[x]]==x;++SG[x]);//求出mex
}
public:
int Mx,tot[N+5];
I void Init()
{
RI i,x,y;for(F.read(m),i=1;i<=m;++i) F.read(x),F.read(y),add(x,y),add(y,x);//连边
for(i=1;i<=n;++i) SG[i]=-1;for(i=1;i<=n;++i)//初始化SG值为-1表示未求解过
!~SG[i]&&(dfs(i),0),Mx<SG[i]&&(Mx=SG[i]),Inc(tot[SG[i]],pw[i]);//统计信息
}
}G1,G2,G3;
int main()
{
RI i,j,ans=0;F.read(n);
for(pw[0]=1,pw[1]=(long long)1e18%X,i=2;i<=n;++i) pw[i]=1LL*pw[i-1]*pw[1]%X;//预处理幂
for(G1.Init(),G2.Init(),G3.Init(),i=0;i<=G1.Mx;++i)
for(j=0;j<=G2.Mx;++j) ans=(1LL*G1.tot[i]*G2.tot[j]%X*G3.tot[i^j]+ans)%X;//统计答案
return printf("%d",ans),0;
}
\(D\)：Merge Triplets（点此看题面）
大致题意： 有\(3n\)个数，你需要把它们分成\(n\)个有序三元组。每次选出每组第一个数中最小的那一个，取出并放入生成序列。求最终生成序列可能的情况数。
结论一
我们发现，由于每次取出最小的数，所以若一个数之后有若干比它小的数（注意是比它小，而不是递减），那么它们都应该属于一个三元组中。
也就是说，一个数之后最多只能有两个数比它小，且它们必然属于一个集合（这里的集合有别于题目中的三元组，大小可以为\(1/2/3\)）。
再考虑下一个比它大的数必然是另一集合的开头的数，进而我们发现一个推论：每一个集合开头的数必然大于先前出现过的所有数。
结论二
结论一实际上只能使得每个集合元素个数小于等于\(3\)，却不能满足这些集合恰好能拼成\(n\)个三元组。
考虑对于大小为\(3\)的集合，它必然是一个三元组；大小为\(1\)的集合，既可以由大小为\(1,1,1\)的三个集合拼成一个三元组，也可以由大小为\(1,2\)的两个集合拼成一个三元组。
而对于大小为\(2\)的集合，只能与大小为\(1\)的集合共同拼成一个三元组。所以我们就得到了结论二：大小为\(2\)的集合个数小于等于大小为\(1\)的集合个数。
显然有了这样两个结论，就已经保证了充要性，那么我们就可以\(DP\)生成序列的方案数了。
关于转移系数
我们设\(f_{i,j}\)表示已经确定了前\(i\)个数，大小为\(1\)的集合个数减去大小为\(2\)的集合个数为\(j\)（\(j\)可能为负，因此我们给它加上\(3n\)）的方案数。
然后发现这道题似乎用刷表法写会更容易。
一开始\(naive\)地去枚举新集合开头的数，也因此要记录下当前集合开头的数，复杂度是\(O(n^4)\)的。（可以用前缀和优化到\(O(n^3)\)，但反正都过不去，懒得写了。。。）
于是被这个思路带偏，然后就走到死胡同里去了。。。
然而实际上，我们考虑只要维护出所有数的相对顺序，而确定\(n\)个数的相对顺序自然就确定了整个序列，也就不需要去枚举具体填什么值了。
假设当前确定了前\(i\)个数，然后加入新的一个集合，有三种情况：
- 新加入的集合大小为\(1\)：根据结论一的推论，这个数必然大于先前所有数，相对大小唯一，转移系数也就是\(1\)。
- 新加入的集合大小为\(2\)：第\(i+2\)个数，肯定小于第\(i+1\)个数，而与已确定的\(i\)个数相比有\(i+1\)种相对大小关系（\(i\)个数有\(i+1\)个空隙），转移系数为\(i+1\)。
- 新加入的集合大小为\(3\)：第\(i+3\)个数，与已确定的\(i\)个数和刚加入的第\(i+2\)个数相比有\(i+2\)种相对大小关系，转移系数在\(i+1\)的基础上再乘一个\(i+2\)。
具体实现详见代码。
代码
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 6000
#define Inc(x,y) ((x+=(y))>=X&&(x-=X))
using namespace std;
int n,X,f[N+5][2*N+5];
int main()
{
RI i,j,k,x;scanf("%d%d",&n,&X),n*=3,f[0][n]=1;//这里先将n乘3，方便后续操作
for(i=0;i^n;++i) for(j=0;j<=2*n;++j)
i+1<=n&&Inc(f[i+1][j+1],f[i][j]),//加入一个数
i+2<=n&&(f[i+2][j-1]=(1LL*(i+1)*f[i][j]+f[i+2][j-1])%X),//加入两个数
i+3<=n&&(f[i+3][j]=((1LL*(i+1)*(i+2))%X*f[i][j]+f[i+3][j])%X);//加入三个数
RI ans=0;for(j=n;j<=2*n;++j) Inc(ans,f[n][j]);return printf("%d",ans),0;//统计并输出答案
}
