UOJ Easy Round #5 题解

A

题目给的限制相当于要使最后所有没被弄坏的格子形成一棵树。

主要到，树需要满足：点数 $-$ 边数 $=1$。不难猜到当 $k$ 很大的时候肯定不能形成树，因为坏掉的格子只能堵住旁边的四条边，而总边数为 $2\times n\times m+n+m$，所以点数的最大值为：
$$2\times n\times m+n+m-k+1$$

当点数大于这个时，直接输出No，否则直接并查集判是否为树即可。

然而这个上界只是我口胡的，所以可能不够松，事实上，我是考虑一种坏掉的格子排布稀疏的形式，使每个坏掉的格子旁边都是好的格子，像这样：

这样的话好的格子数量大概为 $4k+n+m-1$，并且可以发现上面其实不是树，也就是说，合法情况下，好的格子数量是达不到这个上界的，用这个上界来判可能稳一点吧……

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int T,n,m,k;
int posx[100010],posy[100010];
int *id[100010],idtot=0;
int fa[500010],ans;
int findfa(int x){
    
    return x==fa[x]?x:fa[x]=findfa(fa[x]);}
void link(int x,int y){
    
    
	x=findfa(x);y=findfa(y);
	if(x!=y)fa[y]=x; else ans=-1;
}
int fx[2]={
    
    1,0};
int fy[2]={
    
    0,1};

int main()
{
    
    
	scanf("%d",&T);while(T--)
	{
    
    
		scanf("%d %d %d",&n,&m,&k);
		for(int i=1;i<=k;i++)
			scanf("%d %d",&posx[i],&posy[i]);
		if(1ll*n*m>4*k+n+m-1){
    
    
			puts("No");
			continue;
		}
		idtot=0;
		for(int i=1;i<=n;i++){
    
    
			id[i]=new int[m+1];
			for(int j=1;j<=m;j++)
				id[i][j]=++idtot,fa[idtot]=idtot;
		}
		for(int i=1;i<=k;i++)
			id[posx[i]][posy[i]]=0;
		ans=n*m-k-1;
		for(int i=1;i<=n;i++){
    
    
			for(int j=1;j<=m;j++)if(id[i][j]){
    
    
				for(int d=0;d<2;d++){
    
    
					int x=i+fx[d],y=j+fy[d];
					if(x<1||x>n)continue;
					if(y<1)y=m;if(y>m)y=1;
					if(id[x][y])link(id[i][j],id[x][y]),ans--;
				}
			}
		}
		puts(ans==0?"Yes":"No");
	}
}

B

很巧妙的构造题，首先要打表发现一个结论：最优解中不存在长度超过 $2$ 的差不为 $0$ 的等差子序列。

考虑这样的分治构造：对于区间 $[l,r]$，将奇数放在左边，偶数放在右边，然后将所有数除以二，分治处理奇数区间和偶数区间。

对于一个长度为 $3$ 的等差数列，首项和末项奇偶性一定相同，可能是奇-偶-奇，或者是偶-奇-偶，但是上面将这两类分开了，就不存在这两类。

而对于奇-奇-奇和偶-偶-偶，他们的差值为偶数，所以将所有数除以 $2$ 再考虑没有影响，然后递归下去处理即可。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 510

int n,a[maxn],b[maxn];
int tmp[maxn];
void solve(int l,int r){
    
    
	int st=l-1,ed=r+1,p=a[b[l]];
	for(int i=l;i<=r;i++){
    
    
		if(p!=a[b[i]])p=-1;
		if(a[b[i]]&1)tmp[++st]=b[i];
		else tmp[--ed]=b[i];
	}
	if(p>=0)return;
	for(int i=l;i<=st;i++)b[i]=tmp[i],a[b[i]]>>=1;
	for(int i=ed;i<=r;i++)b[i]=tmp[i],a[b[i]]>>=1;
	solve(l,st);solve(ed,r);
}

int main()
{
    
    
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]),b[i]=i;
	solve(1,n);
	for(int i=1;i<=n;i++)
		printf("%d ",b[i]);
}

C

先定义一个暴力dp的状态：$f_{i,j,k}$ 表示前 $i$ 个数分成了 $j+k$ 个集合，其中 $j$ 个集合的最后一个数与 $i$ 奇偶性相同，$k$ 个不同。

题解里提到了一个bx2k拆分：就是每个集合内的数奇偶性相同的拆分，类似的可以定义出 $g_{i,j,k}$。

然后高端操作来了：$f_{i,j,k}=g_{i+1,k+1,j}$。

具体来说，考虑一个红包拆分的方案，假设一个新集合为 { i + 1 } \{i+1\} { i+1}，将每个集合内的元素从大到小排序，对于每个元素可以定义出一个前驱，也就是集合内最小的比他大的数。

从大到小考虑每个数，设他的前驱为 $p$，假如这个数不是集合内的最大值，那么就定义他的新前驱为 $p+1$，否则不变。

根据新前驱，可以构造出一种新的拆分，而这个拆分就是bx2k拆分，且恰好有 $i+1$ 个数，分成了 $k+1$ 个奇偶性相同的集合。

也就是说，每一种红包拆分都唯一对应一种bx2k拆分，反过来也一样。

而 $g_{i,j,k}=S_{\lceil \frac{i}{2}\rceil ,j}\times S_{\lfloor \frac{i}{2}\rfloor ,j}$，其中 $S$ 是第二类斯特林数，所以 $O(n^2)$ 预处理 $S$ 就能求出 $f$ 了。

当然，注意到用到的 $S$ 都在 $\lfloor \frac{i}{2}\rfloor$ 和 $\lceil \frac{i}{2}\rceil$ 这两行上，所以也可以用FFT $O(n\log n)$ 预处理，目前的rk1就是这么做的。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define mod 998244353

int n,m,fac=1;
int s[3010][6010];

int main()
{
    
    
	scanf("%d %d",&n,&m);n++;
	s[0][0]=1;for(int i=1;i<=(n+1)/2;i++)
		for(int j=0;j<=m&&j<=i;j++)
			s[i][j]=((j?s[i-1][j-1]:0)+1ll*j*s[i-1][j]%mod)%mod;
	int ans=0;
	for(int i=0;i<=m;i++)
		ans=(ans+1ll*s[n/2][i]*s[(n+1)/2][m-i+1])%mod;
	for(int i=1;i<=m;i++)fac=1ll*fac*i%mod;
	ans=1ll*ans*fac%mod;
	printf("%d",ans);
}