【题解】JSOIWC2019 Round3

题面

题解:

T1:

先对图进行染色，重新对联通快重新建图

根据四色定理，珂以得出这实际是一颗树

因为树的中心肯定是最佳的决策，所以答案就是树的直径/2（上取整）

#include <bits/stdc++.h>
#define N 1005
using namespace std;
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
inline void write(register int x)
{
    if(!x)putchar('0');if(x<0)x=-x,putchar('-');
    static int sta[20];register int tot=0;
    while(x)sta[tot++]=x%10,x/=10;
    while(tot)putchar(sta[--tot]+48);
}
inline int Min(register int a,register int b)
{
	return a<b?a:b;
}
inline int Max(register int a,register int b)
{
	return a>b?a:b;
}
int n,m,ma[N][N],cnt=0;
int a[]={-1,-1,-1,0,0,1,1,1},b[]={-1,0,1,-1,1,-1,0,1};
int c[N][N];
bool vis[N][N];
inline void dfs(register int x,register int y,register int col)
{
	if(x<1||y<1||x>n||y>m)
		return;
	c[x][y]=col;
	for(register int i=0;i<8;++i)
		if(ma[x][y]==ma[x+a[i]][y+b[i]]&&!c[x+a[i]][y+b[i]])
			dfs(x+a[i],y+b[i],col);
}
struct edgee{
	int to,next;
}e[(N*N)<<1];
int head[N*N],tot=0;
inline void add(register int u,register int v)
{
	e[++tot]=(edgee){v,head[u]};
	head[u]=tot;
}
struct node{
	int X,Y;
	node(int x,int y){
		X=Min(x,y);
		Y=Max(x,y);
	}
	friend bool operator<(node x,node y){
		if(x.X!=y.X){
			return x.X<y.X;
		}
		return x.Y<y.Y;
	}
};
set<node> ed;
inline void dfs2(register int x,register int y)
{
	if(x<1||y<1||x>n||y>m)
		return;
	vis[x][y]=true;
	for(register int i=0;i<8;++i)
		if(c[x][y]==c[x+a[i]][y+b[i]]&&!vis[x+a[i]][y+b[i]])
			dfs2(x+a[i],y+b[i]);
		else if(c[x][y]!=c[x+a[i]][y+b[i]]&&c[x+a[i]][y+b[i]]!=0)
			ed.insert(node(c[x][y],c[x+a[i]][y+b[i]]));
}
int maxv,maxi,dis[N*N];
inline void dfs3(register int x,register int fa){
	dis[x]=dis[fa]+1;
	for(register int i=head[x];i;i=e[i].next)
		if(e[i].to!=fa)
			dfs3(e[i].to,x);
}
int main()
{
	freopen("paint.in","r",stdin);
	freopen("paint.out","w",stdout);
	int T=read();
	while(T--)
	{
		ed.clear();
		cnt=0,tot=0;
		memset(head,0,sizeof(head));
		n=read(),m=read();
		for(register int i=1;i<=n;++i)
			for(register int j=1;j<=m;++j)
			{
				char ch=getchar();
				while(ch!='0'&&ch!='1')
					ch=getchar();
				ma[i][j]=ch=='0'?0:1;
			}
		memset(c,0,sizeof(c));
		for(register int i=1;i<=n;++i)
			for(register int j=1;j<=m;++j)
				if(!c[i][j])
					dfs(i,j,++cnt);
		memset(vis,false,sizeof(vis));
		for(register int i=1;i<=n;++i)
			for(register int j=1;j<=m;++j)
				if(!vis[i][j])
					dfs2(i,j);
		set<node>::iterator iter;
		for(iter=ed.begin();iter!=ed.end();++iter)
		{
			node ii=*iter;
			int jj=ii.X,kk=ii.Y;
			add(jj,kk),add(kk,jj);
		}
		dis[0]=-1;
		dfs3(1,0);
		maxv=maxi=0;
		for(register int i=2;i<=cnt;++i)
			if(dis[i]>maxv)
			{
				maxi=i;
				maxv=dis[i];
			}
		dfs3(maxi,0);
		maxv=0;
		for(register int i=1;i<=cnt;++i)
			if(dis[i]>maxv)
				maxv=dis[i];
		write((maxv+1)>>1),puts("");
	}
	return 0;
}

T2:

神仙题目qaq，学不会啊

官方题解：

首先，如果在某一个时刻，排在左边的人和右边的人之间还有鸽子的话，左边的人一定会先取完两人之间的鸽子。设f[i]为当最后一只鸽子上的数是i时，小X的得分，那么当n=1时，显然f[i]=i。我们从后往前考虑后k只鸽子，每次我们在最左端加入一只鸽子k时，先手的第一步决策只会有两种：

1. 走到新加入的鸽子上。那么原来的先手就变成了后手，先手的得分就是a[k]-f[i];

2. 不走到新加入的鸽子上。那么先手的决策应该和原来相同，先手的得分就是f[i]-a[k]。

因此，每当我们在最左端加入一只鸽子k时，f[i]会变为max(a[k]-f[i],f[i]-a[k])，即减去a[k]后取绝对值。因此，原问题就变成了这样一个问题：

最初你有一个一次函数f[i]=i，你会进行若干次操作，每次将函数向下平移若干单位后取绝对值，然后询问这个函数在某个点的值。

考虑第一次操作，你会将一个一次函数向下平移x格，然后取绝对值，可以发现f[i]=f[2*k-i]，也就是之后的函数关于x对称，且对称轴右边依然是一个一次函数f[i]=i-x。因此只要继续计算x及以后的位置上的函数值，x以前的函数值可以根据后面的直接算出。求出f[0]-f[∑a[i]]，大于∑a[i]的询问直接回答即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=200005,M=2000005;
int read(){
	int f=1,g=0;
	char ch=getchar();
	for (;!isdigit(ch);ch=getchar()) if (ch=='-') f=-1;
	for (;isdigit(ch);ch=getchar()) g=g*10+ch-'0';
	return f*g;
}
int n,m,a[N],sum,f[M*2];
void build(int l,int r,int x){
	if (!x){
		for (int i=l;i<=r;i++)
		f[i]=i-l;
		return;
	}
	int mid=l+a[x];
	build(mid,r,x-1);
	for (int i=l;i<mid;i++)
	f[i]=f[mid+mid-i];
}
int main(){
	freopen("pigeon.in","r",stdin);
	freopen("pigeon.out","w",stdout);
	n=read();
	for (int i=1;i<n;i++) {a[i]=read();sum+=a[i];}
	build(0,2*sum,n-1);
	m=read();
	while (m--){
		int x=read();
		if (x>sum) printf("%d ",x-sum);
		else printf("%d ",f[x]);
	}
	printf("\n");
	return 0;
}

T3:

考的是卡特兰数，可惜我不会通项公式

首先，设f[i]为拥有i个节点的不同形态二叉树数量，g[i]为拥有i个节点的所有不同形态二叉树的叶子节点数量和，那么答案就是要求\(\frac{g[n]}{f[n]}\) 。通过打表可以发现一个结论，g[n]=f[n-1]*n，证明如下：

1、对于每棵n个点的二叉树，如果里面有k个叶节点，那么我们分别把这k个叶子删去会得到k棵n-1个点的二叉树，也就是所有n个节点的二叉树中的每个叶子都唯一对应一棵n-1个节点的二叉树；

2、对于每棵n-1个点的二叉树，有n个位置可以接上一个新的叶子节点，所以每棵n-1个节点的二叉树都对应（所有n个节点的二叉树中的所有叶子中的）n个叶子。

因此，答案就是 \(\frac{f[n-1]*n}{f[n]}\)。其中f[n]表示的是n个节点的不同形态二叉树数量，也就是卡特兰数，其通项公式为\(\frac{C_n^{2n}}{n+1}\) ，化简得答案为\(\frac{n^2+n}{4n-2}\) 。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll p=2148473647;
ll qpow(ll x,ll k){
	ll t=1;
	for (;k;k>>=1){
		if (k&1) t=t*x%p;
		x=x*x%p;
	}
	return t;
}
ll n;
int main(){
	freopen("game.in","r",stdin);
	freopen("game.out","w",stdout);
	scanf("%lld",&n);
	printf("%lld\n",n*(n+1)/2%p*qpow((n*2-1)%p,p-2)%p);
	return 0;
}

还是太菜了啊~

T1xjb写了个以为是暴力的正解，t2博弈搜索写挂，t3卡特兰数也写挂了qaq

真是菜啊

深深地感受到自己的弱小~