AtCoder Grand Contest 019 题解

传送门

\(A\)

咕咕

int a,b,c,d,n,t;
int main(){
	scanf("%d%d%d%d%d",&a,&b,&c,&d,&n);
	t=n&1,n-=t,a*=8,b*=4,c*=2;
	printf("%lld\n",1ll*min(min(a,b),min(c,d))*(n>>1)+(min(min(a,b),c)>>1)*t);
	return 0;
}

\(B\)

先不考虑结果不变的操作，发现如果一个翻转的区间\([l,r]\)满足\(s[l]=s[r]\)那么我们现在可以选择操作\([l+1,r-1]\)而使得最终的序列和翻转\([l,r]\)之后的序列相等，那么我们就不计数\([l,r]\)，这样我们只要数出有多少对\([l,r]\)满足\(s[l]\\neq s[r]\)，最后答案\(+1\)即可

typedef long long ll;
const int N=2e5+5;
char s[N];int cnt[26],n,sum;ll res;
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	fp(i,1,n)res+=sum-cnt[s[i]-'a'],++cnt[s[i]-'a'],++sum;
	printf("%lld\n",res+1);
	return 0;
}

\(C\)

直接把那个矩阵中的点拿出来，然后按纵坐标从小到大排序，以\(x\)做一个最长上升子序列，如果长度\(k < min(x_2 - x_1,y_2 - y_1) + 1\)，那么可以拐角\(k\)次，减少\((20-5\pi)k\)

否则只能拐角\(k-1\)次然后再走一个半圆，减少\((20-5\pi)(k-1)\)再加上\((10\pi -20)\)

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int N=2e5+5;const double Pi=acos(-1.0);
int x[N],y[N],id[N],f[N],num[N];
int n,tot,cnt;
inline bool cmp(const int &a,const int &b){return y[a]<y[b];}
int main(){
	int x1,y1,x2,y2;
	scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&n);
	fp(i,1,n)scanf("%d%d",&x[i],&y[i]);
	if(x1>x2)swap(x1,x2),swap(y1,y2);
	if(y1>y2){
		swap(y1,y2);
		fp(i,1,n)y[i]=y1+y2-y[i];
	}
	fp(i,1,n)id[i]=i;
	sort(id+1,id+1+n,cmp);
	fp(i,1,n){
		R int u=id[i];
		if(y[u]>=y1&&y[u]<=y2&&x[u]>=x1&&x[u]<=x2)
			num[++tot]=x[u];
	}
	cnt=0,f[cnt]=-1;
	fp(i,1,tot){
		if(num[i]>f[cnt])f[++cnt]=num[i];
		else{
			R int k=lower_bound(f+1,f+1+cnt,num[i])-f;
			f[k]=num[i];
		}
	}
	R double res;
	if(cnt<min(x2-x1,y2-y1)+1)
		res=100.0*(x2-x1+y2-y1)-(20-Pi*5)*cnt;
	else res=100.0*(x2-x1+y2-y1)-(20-Pi*5)*(cnt-1)+(10*Pi-20);
	printf("%.12lf\n",res);
	return 0;
}

\(D\)

首先枚举\(A\)中的那一个位置最终和\(B_1\)匹配，然后对于每一个位置如果和最终的位置不等，那么判一下在过程中是否会碰到\(1\)，如果是的话可以在那里变成

否则我们对于每一个无法达到的点求出额外向左\(/\)右移动的最小距离，如果令一个左边最远的走左边，那么剩下的也都可以走左边，否则这个左边最远的必须走右边。同理次远也是一样

总的复杂度\(O(n^2\log n)\)

//quming
#include<bits/stdc++.h>
#define R register
#define fi first
#define se second
#define pb emplace_back
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
typedef pair<int,int> pi;
const int N=2005,inf=0x3f3f3f3f;
char s[N*3],s1[N];
int sum[N*3],nl[N*3],nr[N*3],res,len;
vector<pi>vc;
void init(){
	nl[0]=-inf;
	fp(i,1,len*3)nl[i]=(s[i]=='1'?i:nl[i-1]);
	nr[len*3+1]=inf;
	fd(i,len*3,1)nr[i]=(s[i]=='1'?i:nr[i+1]);
	fp(i,1,len*3)sum[i]=sum[i-1]+(s[i]=='1');
}
inline int findl(R int x){return min(inf,x-nl[x]);}
inline int findr(R int x){return min(inf,nr[x]-x);}
int main(){
	scanf("%s%s",s1+1,s+1),res=inf;
	len=strlen(s+1);
	fp(i,len+1,len*3)s[i]=s[i-len];
	init();
	fp(i,1,len*2+1){
		vc.clear();
		R int c=0;
		fp(j,1,len)if(s1[j]!=s[i+j-1]){
			++c;
			R int r=j+len,l=j+i-1;
			if(l>r)swap(l,r);
			if(sum[r]-sum[l-1]==0)
			vc.pb(pi(findl(l),findr(r)));
		}
		vc.pb(pi(0,0));
		sort(vc.begin(),vc.end());
		reverse(vc.begin(),vc.end());
		R int tmp=inf,mx=0;
		for(auto p:vc){
			if(p.fi!=inf&&mx!=inf)cmin(tmp,mx*2+p.fi*2);
			cmax(mx,p.se);
			if(mx==inf)break;
		}
		if(tmp!=inf)cmin(res,tmp+abs(len+1-i)+c);
	}
	if(res==inf)res=-1;
	printf("%d\n",res);
	return 0;
}

\(E\)

想到这些方法的都是什么神仙啊……

首先有用的位置只有两个，两个全\(1\)或者一个\(1\)一个\(0\)，方便起见把全\(1\)记做中间点，一个\(1\)一个\(0\)记做左点，一个\(0\)一个\(1\)记做右点。记中间点个数为\(A\)，左点和右点的个数都是\(B\)

我们先匹配再考虑顺序，对于一个\((a_i,b_i)\)的匹配，把\(a_i\)向\(b_i\)连一条边，那么最终的图肯定是若干个环加若干条链，环上都是中间点，链上开头和结尾分别是左右点，中间都是中间点。对于环，上面操作顺序任意，对于链，操作顺序必须固定

sol1

设\(f[i][j]\)表示把\(j\)个中间点放到\(i\)条链中的方案数，则\(f[i][j]=\sum _{k\geq 0}{f[i-1][j-k]\over (k+1)!}\)，分母表示链上\(k+1\)条边的顺序固定，那么最终的答案就是\(A!B!(A+B)!\sum_{i=0}^A f[B][i]\)，其中\((A+B)!\)表示边随便排列，而\(A!\)和\(B!\)代表两种点之间有标号

然后我们每一次转移相等于乘上一个多项式\(\sum_{i\geq 0}{1\over (i+1)!}x^i\)，那么多项式快速幂就行了，复杂度\(O(n\log n)\)

sol2

另一种方法是设\(f[i][j]\)表示一共放了\(i\)个中间点和\(j\)个左点，则

\[\begin{aligned}
f[i][j]=i\times j\times f[i-1][j]+j^2\times f[i][j-1]
\end{aligned}
\]

前一个是表示插入一个中间点，它的标号任意，即可以随便和之前一个交换标号，所以乘\(i\)，然后可以插在任意一条链的后面，所以乘\(j\)

后一个是表示插入一个新的左点，同理标号任意所以乘\(j\)，又因为可以选择任意一个右点所以再乘\(j\)

复杂度\(O(n^2)\)已经可以通过了

不过还可以用多项式优化，设\(g[i][j]={f[i][j]\over (j!)^2(i!)}\)，则有\(g[i][j]=g[i][j-1]+j\times g[i-1][j]\)

原来的可以看成是一个网格从左上出发到右下，每次往下走就乘上\(ij\)，往右走就乘上\(j^2\)，求所有路径权值和，变成\(g[i][j]\)之后就是只有往下走会乘上\(j\)

那么我们枚举在第\(i\)列走了几步，发现第\(i\)列的生成函数就是\({1\over 1-ix}\)，答案就是所有列的生成函数之积，直接分治\(NTT+\)多项式求逆即可，复杂度\(O(n\log^2 n)\)

因为比较懒所以只写了\(O(n^2)\)的

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int P=998244353;
inline void upd(R int &x,R int y){(x+=y)>=P?x-=P:0;}
inline int add(R int x,R int y){return x+y>=P?x+y-P:x+y;}
inline int dec(R int x,R int y){return x-y<0?x-y+P:x-y;}
inline int mul(R int x,R int y){return 1ll*x*y-1ll*x*y/P*P;}
int ksm(R int x,R int y){
	R int res=1;
	for(;y;y>>=1,x=mul(x,x))(y&1)?res=mul(res,x):0;
	return res;
}
const int N=10005;
char s[N],t[N];int fac[N],ifac[N],f[N][N],n,cnta,cntb;
inline int C(R int n,R int m){return m>n?0:1ll*fac[n]*ifac[m]%P*ifac[n-m]%P;}
inline void init(int n=10000){
	fac[0]=ifac[0]=1;fp(i,1,n)fac[i]=mul(fac[i-1],i);
	ifac[n]=ksm(fac[n],P-2);fd(i,n-1,1)ifac[i]=mul(ifac[i+1],i+1);
}
int main(){
	init();
	scanf("%s%s",s+1,t+1),n=strlen(s+1);
	fp(i,1,n){
		cnta+=(s[i]=='1'&&t[i]=='1');
		cntb+=(s[i]=='1'&&t[i]=='0');
	}
	f[0][0]=1;
	fp(j,1,cntb)f[0][j]=mul(fac[j],fac[j]);
	fp(i,1,cnta)fp(j,1,cntb)
		f[i][j]=(1ll*i*j%P*f[i-1][j]+1ll*j*j%P*f[i][j-1])%P;
	R int res=0;
	fp(i,0,cnta){
		R int j=cnta-i;
		upd(res,1ll*f[i][cntb]*fac[j]%P*fac[j]%P*C(cnta,j)%P*C(cnta+cntb,j)%P);
	}
	printf("%d\n",res);
	return 0;
}

\(F\)

好秒……

首先假设现在还剩\(n\)个\(Yes\)和\(m\)个\(No\)，那么肯定是选择较多的那个回答，如果一样的话随便蒙一个

然后我们把这个东西放到一个坐标系里，那么一种回答的方案相当于是从\((n,m)\)出发到\((0,0)\)，如果以\(y=x\)把坐标系分成两部分，则在这条线下面往左走会有贡献，在上面往下走会有贡献

先假设\(n=m\)，且走的过程中没有碰到过对角线，那么不管在上面走还是在下面走贡献都是\(n\)

否则先假设\(n\geq m\)，那么在走到对角线之前，一定会先往左走\(n-m\)步，如果到了对角线，我们以每次碰到对角线为界把路径分成若干部分，那么每一部分的贡献都是之前说的没有碰到过对角线的贡献了，所以总的贡献必定是\(n\)，同理当\(m\geq n\)的时候贡献一定是\(m\)

然后是对角线上的点，不管往哪边走贡献都是\({1\over 2}\)，那么我们对于每个点判断一下经过它的概率是多少即可

//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int P=998244353;
inline void upd(R int &x,R int y){(x+=y)>=P?x-=P:0;}
inline int add(R int x,R int y){return x+y>=P?x+y-P:x+y;}
inline int dec(R int x,R int y){return x-y<0?x-y+P:x-y;}
inline int mul(R int x,R int y){return 1ll*x*y-1ll*x*y/P*P;}
int ksm(R int x,R int y){
	R int res=1;
	for(;y;y>>=1,x=mul(x,x))(y&1)?res=mul(res,x):0;
	return res;
}
const int N=1e6+5;
int fac[N],ifac[N],n,m,res;
inline int C(R int n,R int m){return m>n?0:1ll*fac[n]*ifac[m]%P*ifac[n-m]%P;}
inline int calc(R int n,R int m){return C(n+m,n);}
inline void init(int n=1e6){
	fac[0]=ifac[0]=1;fp(i,1,n)fac[i]=mul(fac[i-1],i);
	ifac[n]=ksm(fac[n],P-2);fd(i,n-1,1)ifac[i]=mul(ifac[i+1],i+1);
}
int main(){
	init();
	scanf("%d%d",&n,&m);
	fp(i,1,min(n,m))upd(res,mul(calc(i,i),calc(n-i,m-i)));
	res=mul(res,ksm(mul(calc(n,m),2),P-2));
	upd(res,max(n,m));
	printf("%d\n",res);
	return 0;
}