AtCoder Grand Contest 020 题解

传送门

怎么又是\(tourist\)神仙的题……

\(A\)

咕咕

int n,a,b;
int main(){
	scanf("%d%d%d",&n,&a,&b);
	puts(((b-a-1)&1)?"Alice":"Borys");
	return 0;
}

\(B\)

考虑从后往前做，假设考虑到\(a_i\)，且只考虑第\(a_{i+1}\)到\(a_n\)的答案为\(s\)，那么考虑了\(a_i\)的答案\(p\)要满足\(p/a_i\times a_i=s\)（这里是下取整），因为这里必有\(a_i|s\)，所以\(p\)需要满足\(s+a_i-1\geq p\geq s\)，那么我们就可以把\(p\)的范围给求出来了，这样一直求到\(a_1\)就可以了，注意还要保证\(p\)恒为\(a_{p-1}\)的倍数，所以还需要处理一下范围

//quming
#include<bits/stdc++.h>
#define R register
#define pb emplace_back
#define gg return puts("-1"),0
#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 long long ll;
const int N=1e5+5;
int a[N],n;ll mn,mx,l,r;
inline int dec(R int x,R int y){return y?x-y:0;}
int main(){
	scanf("%d",&n);
	fp(i,1,n)scanf("%d",&a[i]);
	mx=mn=2,a[0]=1;
	if(2%a[n])gg;
	for(R int i=n;i;--i){
		l=mn,r=mx;
		mn=(l+a[i-1]-1)/a[i-1]*a[i-1];
		mx=(r+a[i]-1)/a[i-1]*a[i-1];
		if(mn>mx)gg;
	}
	printf("%lld %lld\n",mn,mx);
	return 0;
}

\(C\)

考虑把空集也算上的话中位数是\(p={\sum a_i\over 2}\)（因为对于每一种取法，它的补集的和与它的和必然是\(\sum a_i\)），那么去掉空集的话中位数就是\(p\)的后继了

//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=2005,M=4e6+5;
bitset<M>vis;int a[N],n,sum,res;
int main(){
	scanf("%d",&n);
	vis[0]=1;
	fp(i,1,n)scanf("%d",&a[i]),sum+=a[i],vis|=vis<<a[i];
	res=(sum+1)>>1;
	fp(i,res,sum)if(vis[i])return printf("%d\n",i),0;
	puts("QAQ");
	return 0;
}

\(D\)

自己想想觉得很麻烦，不过似乎并没有啊……

首先，最小长度\(k={(\max(a,b))\over \min(a,b)+1}\)（上取整），就是考虑把其中一个字母塞到另外一个字母的中间

如果\(k=1\)，随便搞，否则的话考虑贪心

对于当前字母的方法，需要满足以下两个条件，一个是连续长度不能超过\(k+1\)，另一个是后面的字母产生的也不会超过\(k+1\)

那么不难发现前缀一段一定是\(AA..ABAA..AB...\)就是\(A\)重复\(k\)遍之后后面接一个\(B\)

那么假设现在还剩\(a\)个\(A\)和\(b\)个\(B\)，那么当前位置可以当\(A\)当且仅当\(b\leq ka\)，因为最坏的情况是一个\(A\)后接\(k\)个\(B\)，而且不难发现后缀一段一定都是形如这种情况

所以我们只需要找到前缀和后缀的分界点，然后就可以\(O(1)\)计算每一个位置的值了。注意最优情况下分界点处必定是一个\(A\)，且这个\(A\)是前后缀共用的，假设分界点及其之前有\(nb\)个\(B\)和\(na\)个\(A\)，那么有\(nb\leq \max(0,\lfloor{{na-1\over k}\rfloor})\)，同时也有\(na=a-\lceil{{b-nb\over k}\rceil}+1\)，带入之后有\(nb\leq \lfloor{{a-\lceil{{b-nb\over k}\rceil}\over k}\rfloor}\)，发现当\(nb\)增大时，左边递增，右边递减，那么二分找到最大的\(nb\)即可

然后没有然后了

//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;
typedef long long ll;
const char s[2]={'A','B'};
int a,b,c,d,q,k,nb;ll lim;
inline int calc(R int x){return (a-(b-x+k-1)/k)/k;}
inline int find(){
	R int l=0,r=b,mid,ans=0;
	while(l<=r){
		mid=(l+r)>>1;
		mid<=calc(mid)?(ans=mid,l=mid+1):r=mid-1;
	}
	return ans;
}
int main(){
//	freopen("testdata.in","r",stdin);
	for(scanf("%d",&q);q;--q){
		scanf("%d%d%d%d",&a,&b,&c,&d),--c;
		k=(a+b)/(a<b?a+1:b+1);
		if(k==1)fp(i,c,d-1)putchar(s[(i+(b>a))&1]);
		else{
			nb=find();
//			printf("qwq %d %d %d %d\n",a,b,k,nb);
			lim=nb+a-(b-nb+k-1)/k+1;
			fp(i,c,d-1)putchar(i<lim?s[i%(k+1)==k]:s[(a+b-i)%(k+1)>0]);
		}
		putchar('\n');
	}
	return 0;
}

\(E\)

首先设\(f(s)\)表示串\(s\)的压缩方案，那么只要考虑\(s\)的开头字母是单独出现还是被压缩了即可

类似的我们可以得到对于子集求和的算法，即设\(f(s)\)表示对\(s\)这个串的子集和合法压缩方案，被压缩的情况和之前一样，只不过枚举压缩的长度和次数的时候需要把这几段取一个按位与，如果如果开头字母单独出现且开头字母是\(1\)需要乘上\(2\)（因为此时子集中开头可以是\(1\)也可以是\(0\)）

这个爆搜其实是可以过的……因为不同的串\(s\)的数量只有大约\(50000\)个……

证明什么的并没有看懂……

//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;
}
map<string,int>dp;
inline string operator &(const string &a,const string &b){
	R int n=a.length();string c(n,'0');
	fp(i,0,n-1)c[i]=(a[i]=='1'&&b[i]=='1'?'1':'0');
	return c;
}
int dfs(string s){
	if(s.empty())return 1;
	if(dp.count(s))return dp[s];
	if(s.length()==1)return s[0]-'0'+1;
	R int res=mul(s[0]=='1'?2:1,dfs(s.substr(1)));
	R int n=s.length();
	fp(d,1,n){
		string t=s.substr(0,d);
		for(R int k=d;k<=n-d;k+=d){
			t=t&s.substr(k,d);
			upd(res,mul(dfs(t),dfs(s.substr(k+d))));
		}
	}
	return dp[s]=res;
}
int main(){
	string s;cin>>s;
	printf("%d\n",dfs(s));
	return 0;
}

\(F\)

首先默认长度最长的那一条弧放在\([0,x]\)的位置上，然后考虑其它弧的左端点的位置

有一个套路，我们把左端点位置的整数部分和小数部分分开考虑，那么整数部分只有\(n\)种可能，而小数部分虽然可能性有无数种，但是它们之间的相对顺序只有\(n!\)种（默认互不相同，因为连续型随机变量取值相同的概率可以视为\(0\)），而且只有这个相对顺序会对答案有影响

那么我们\(n!\)爆搜小数部分的相对顺序，把圆上给拆成\(n\times c\)个点，其中第\((i,j)\)个点表示整数部分为\(i\)，小数部分为\(j\)，然后设\(f[i][j][k]\)表示现在考虑到点\(i\)，当前最远能到点\(j\)，已经选了的点的集合为\(k\)的方案数，转移即可

//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;
typedef long long ll;
int h[15],a[15],vis[15],n,c,lim;
ll f[2][305][(1<<5)+5];double ans,pw;
void solve(){
	memset(f,0,sizeof(f));
	R int t=0;
	f[t][min(c*n,a[n]*n)][0]=1;
	fp(i,1,c*n-1)if(i%n){
		memset(f[t^1],0,sizeof(f[t^1]));
		R int to=i%n-1;
		fp(j,i,c*n)fp(k,0,lim-1)if(f[t][j][k]){
			f[t^1][j][k]+=f[t][j][k];
			if(k>>to&1^1)f[t^1][min(c*n,max(j,i+a[h[to+1]]*n))][k^(1<<to)]+=f[t][j][k];
		}
		t^=1;
	}
	ans+=f[t][c*n][lim-1];
}
void dfs(int dep){
	if(dep>=n)return solve();
	fp(i,1,n-1)if(!vis[i]){
		h[dep]=i,vis[i]=1;
		dfs(dep+1);
		vis[i]=0;
	}
}
int main(){
//	freopen("testdata.in","r",stdin);
	scanf("%d%d",&n,&c);
	fp(i,1,n)scanf("%d",&a[i]);
	sort(a+1,a+1+n),lim=(1<<(n-1));
	dfs(1);
	pw=1;fp(i,1,n-1)pw*=c;
	ans*=1.0/pw;
	pw=1;fp(i,2,n-1)pw*=i;
	ans*=1.0/pw;
	printf("%.12lf\n",ans);
	return 0;
}