CODE FESTIVAL 2017 Final题解

传送门

(A)

咕咕

const int N=55;
const char to[]={"AKIHABARA"};
char s[N];int n;
int main(){
	scanf("%s",s),n=strlen(s);
	R int i=0,j=0;
	for(;i<n;){
		while(j<9&&s[i]!=to[j]&&to[j]=='A')++j;
		if(j>=9||s[i]!=to[j])return puts("NO"),0;
		++i,++j;
	}
	while(j<9&&to[j]=='A')++j;
	puts(j==9?"YES":"NO");
	return 0;
}

(B)

为了不回文，必须得(ABCABC...)这样放，那么三个字母出现次数之差不能超过(1)

const int N=1e5+5;
char s[N];int cnt[3],n,mx;
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	fp(i,1,n)++cnt[s[i]-'a'];
	mx=max(cnt[0],max(cnt[1],cnt[2]));
	if(!cnt[0]||!cnt[1]||!cnt[2])return puts(mx<=1?"YES":"NO"),0;
	fp(i,0,2)if(cnt[i]<mx-1)return puts("NO"),0;
	puts("YES");
	return 0;
}

(C)

首先每个(d)的出现次数不能超过(2)否则答案必定为(0)，那么接下来记录一下每个(d)的出现次数然后爆搜每个(d)是位于(d)还是(24-d)就行了

//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=35,inf=0x3f3f3f3f;
int cnt[N],n,res;
inline int min(R int x,R int y){return x<y?x:y;}
inline int abs(R int x){return x<0?-x:x;}
void dfs(int pos,int s,int ret){
	if(ret<=res)return;
	if(pos==12){
		if(cnt[12]){
			fp(i,1,23)if(s>>i&1)cmin(ret,abs(12-i));
			cmin(ret,12);
		}
		cmax(res,ret);
		return;
	}
	if(!cnt[pos])return dfs(pos+1,s,ret),void();
	cmin(ret,pos);
	if(cnt[pos]==2){
		fp(i,1,23)if(s>>i&1)cmin(ret,abs(pos-i)),cmin(ret,abs(24-pos-i));
		cmin(ret,abs(pos-(24-pos)));
		dfs(pos+1,s|(1<<pos)|(1<<(24-pos)),ret);
		return;
	}
	R int tmp=ret;
	fp(i,1,23)if(s>>i&1)cmin(tmp,abs(pos-i));
	dfs(pos+1,s|(1<<pos),tmp);
	tmp=ret;
	fp(i,1,23)if(s>>i&1)cmin(tmp,abs(24-pos-i));
	dfs(pos+1,s|(1<<(24-pos)),tmp);
}
int main(){
	scanf("%d",&n);
	for(R int i=1,x;i<=n;++i)scanf("%d",&x),++cnt[x];
	if(cnt[0]||cnt[12]>1)return puts("0"),0;
	fp(i,1,11)if(cnt[i]>2)return puts("0"),0;
	dfs(1,0,inf);
	printf("%d
",res);
	return 0;
}

(D)

首先选的顺序肯定是按(h_i+p_i)排序之后再选最优的（证明的话，可以考虑一个合法的选的序列，对于每一个(i)必须满足(sum_{jleq i} hleq h_i+p_i)，因为前缀和递增所以(h_i+p_i)也必须非降才是），然后直接(dp)就是了

//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 int N=5005;const ll inf=0x3f3f3f3f3f3f3f3f;
int a[N],b[N],c[N],id[N],n;ll mn[N];
inline bool cmp(const int &x,const int &y){return c[x]==c[y]?b[x]<b[y]:c[x]<c[y];}
int main(){
	scanf("%d",&n);
	fp(i,1,n)scanf("%d%d",&a[i],&b[i]),c[i]=a[i]+b[i],id[i]=i;
	sort(id+1,id+1+n,cmp);
	memset(mn,0x3f,sizeof(mn));
	mn[0]=0;
	fp(i,1,n){
		R int t=n-1;
		while(mn[t]==inf)--t;
		fd(j,t,0)if(mn[j]<=a[id[i]])cmin(mn[j+1],mn[j]+b[id[i]]);
	}
	fd(i,n,0)if(mn[i]!=inf)return printf("%d
",i),0;
	return 0;
}

(E)

差分之后等价于每次(l_i)位置(+1)，(r_i+1)位置(-1)，而此时回文的条件就是对于每个(i)有(a_i+a_{n-2-i})是(26)的倍数（最中间位置除外），因为每个连通块的权值之和不变，所以要满足每个连通块权值之和为(26)的倍数（包含最中间位置那个连通块除外）

//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=1e5+5;
char s[N];int fa[N],b[N],sum[N],vis[N],n,m;
inline int val(R int x){return x<0?x+26:x;}
inline int find(R int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	fp(i,1,n+1)s[i]-='a',fa[i]=i;
	s[n+1]=0;
	scanf("%d",&m);
	for(R int i=1,l,r;i<=m;++i)scanf("%d%d",&l,&r),fa[find(r+1)]=find(l);
	fp(i,1,n+1)b[i]=val(s[i]-s[i-1]);
	fp(i,1,(n+1)>>1)fa[find(n+2-i)]=find(i);
	fp(i,1,n+1)sum[find(i)]+=b[i];
	if((n+1)&1)vis[find((n+2)>>1)]=1;
	fp(i,1,n+1)if(i==find(i)&&sum[i]%26)
		if(!vis[i])return puts("NO"),0;
	puts("YES");
	return 0;
} 

(F)

手玩了一下(k)较小的情况去考虑对应的(n)……

首先对于前(k)行，每行都令(1)开头，剩下的数依次从(2)取到(n)，这样的话总共需要(n=k(k-1)+1)个数，且第(i)行的第(2)到(k)个数依次是((i-1)(k-1)+2)到(i(k-1)+1)，后面为了方便起见用(st[i][j])表示第(i)行第(j)列的数

对于接下来的每(k)行，依次令(st[1][j])开头，然后在(2)到(k)行中各取一个数，共取(k-1)组，要保证选出的(k-1)组中任意两组没有重复的数，那么只要以(j-1)为步长，以第(2)行中的第(2)到第(k)个数开头，就能保证取完下面所有数了

然而对于两组开头不一样的行，直接这样取可能会有大于一个重复的情况，注意到一种步长会导致这种情况当且仅当步长为(k-1)的因子，那么只要保证(k-1)是个质数就行了，取(k=38)即可

具体细节可以看代码理解

//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=1e5+5;
vector<int>st[N];int n,k,tot;
inline int add(R int x,R int y){return x+y>=k-1?x+y-k+1:x+y;}
int main(){
	k=38,n=k*(k-1)+1,tot=1;
	printf("%d %d
",n,k);
	fp(i,1,k){
		printf("%d ",1);
		st[i].resize(k-1);
		fp(j,0,k-2)st[i][j]=++tot;
		fp(j,0,k-2)printf("%d ",st[i][j]);
		puts("");
	}
	fp(i,0,k-2){
		fp(s,0,k-2){
			R int p=s;
			printf("%d ",st[1][i]);
			fp(j,2,k)printf("%d ",st[j][p]),p=add(p,i);
			puts("");
		}
	}
	return 0;
}

(G)

发现要让剩下的石子最少，每次一定是取从左往右第一个可以操作的操作

记(f_i)表示(i)到(n)的数中总的操作次数，如果(a_ileq i)，那么(f_i=f_{i+1}+(f_{i+1}+a_i)/i)（下取整），最终的分数就是(sum a_i-f_1)

前面总和很好求，所以我们转化为来求(sum f_1)

注意到上面的转移之和(f_{i+1})的值有关，且(f_{i})是(O(n^2))级别的，那么我们记(s_{i,j})表示对于(i)，(f_i=j)的方案数，然后枚举当前数是什么，转移即可

复杂度(O(n^4))

//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=1e9+7;
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=105,M=N*N;
int f[N][M],dv[N][M],n,p,s,res,sum;
int main(){
	scanf("%d%d",&n,&p);
	f[n][0]=1;
	fp(i,1,n)fp(j,1,n*n/i)dv[i][i*j]=j;
	fp(i,1,n)fp(j,1,n*n)if(!dv[i][j])dv[i][j]=dv[i][j-1];
	fd(i,n,1){
		if(p>i)fp(j,0,s)f[i-1][j]=mul(f[i][j],p-i);
		R int t=s;
		fp(j,0,s)if(f[i][j])fp(k,0,min(p,i)){
			upd(f[i-1][j+dv[i][j+k]],f[i][j]);
			cmax(t,j+dv[i][j+k]);
		}
		s=t;
	}
	fp(i,0,s)upd(res,mul(i,f[0][i]));
	sum=mul(n*p*(p+1)>>1,ksm(p+1,n-1));
	printf("%d
",dec(sum,res));
	return 0;
} 

(H)

首先发现一格如果左上，右上，左下，右下四个方位中的一个没有冰山，那么他最终肯定会消失

还有另一种方法是把一个大矩形分成四块，并把左上和右下或右上和左下的冰山全部消掉，然后剩下的两个部分互不影响了

那么设(f[lx][rx][ly][]ry])表示删到只剩矩形([lx,ly,rx,ry])中的元素时，最少要删多少，然后枚举在哪里分割矩形转移即可

具体可以看题解的图理解，复杂度(O(n^6))

记忆化搜索+剪枝似乎比直接dp快到不知道哪里去了

//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=45,inf=0x3f3f3f3f;
char a[N][N];int f[N][N][N][N],s[N][N];
int px,py,n,m,res;
inline int qs(R int x,R int y,R int xx,R int yy){
	return s[xx][yy]+s[x-1][y-1]-s[xx][y-1]-s[x-1][yy];
}
inline int min(R int x,R int y){return x<y?x:y;}
inline int get(R int lx,R int ly,R int rx,R int ry){
	return min(min(qs(lx,ly,px,py),qs(px,py,rx,ry)),
			min(qs(lx,py,px,ry),qs(px,ly,rx,py)));
}
int main(){
//	freopen("testdata.in","r",stdin);
	scanf("%d%d",&n,&m);
	fp(i,1,n)scanf("%s",a[i]+1);
	fp(i,1,n)fp(j,1,m){
		if(a[i][j]=='P')px=i,py=j;
		s[i][j]=s[i-1][j]+s[i][j-1]+(a[i][j]=='#')-s[i-1][j-1];
	}
	memset(f,0x3f,sizeof(f));
	f[1][1][n][m]=0,res=inf;
	fp(lx,1,n)fp(ly,1,m)fd(rx,n,lx)fd(ry,m,ly)
		if(f[lx][ly][rx][ry]!=inf){
			R int ret=f[lx][ly][rx][ry];
			if(px>=lx&&px<=rx&&py>=ly&&py<=ry)cmin(res,ret+get(lx,ly,rx,ry));
				else cmin(res,ret);
			ret+=qs(lx,ly,rx,ry);
			fp(x,lx,rx+1)fp(y,ly,ry+1)
				if(!((x==lx||x==rx+1)&&(y==ly&&y==ry+1))){
					R int val=qs(lx,ly,x-1,y-1)+qs(x,y,rx,ry);
					if(x>lx&&y>ly&&!(px>=x&&px<=rx&&py>=y&&py<=ry))
						cmin(f[lx][ly][x-1][y-1],ret-val);
					if(x<=rx&&y<=ry&&!(px<x&&px>=lx&&py<y&&py>=ly))
						cmin(f[x][y][rx][ry],ret-val);
					val=qs(lx,y,x-1,ry)+qs(x,ly,rx,y-1);
					if(x>lx&&y<=ry&&!(px>=x&&px<=rx&&py<y&&py>=ly))
						cmin(f[lx][y][x-1][ry],ret-val);
					if(x<=rx&&y>ly&&!(px<x&&px>=lx&&py>=y&&py<=ry))
						cmin(f[x][ly][rx][y-1],ret-val);
				}
		}
	printf("%d
",res);
	return 0;
}

(I)

方便起见把人和排名都设为(0)到(2^n-1)

记(a_i)表示排名为(i)的人，则对于任意(k)，有(a_ileq a_{i|2^k}(2^k otin i))

这个考虑归纳证明，不妨令(i=2p)，则排名为(i)的人就是左边排名为(p)的人和右边排名为(p)的人里较小的那个，而排名为(i|2^k)的是左边排名为(p+2^{k-1})和右边排名为(p+2^{k-1})的，根据归纳证明不管左边右边都有(a_pleq a_{p|2^{k-1}})，所以有(a_ileq a_{i|2^k})成立

然后我们对于每个(i)把(a_i)的取值范围求出来，之后扫描线加贪心求出每个(a_i)的值就好了，最后原序列中第(i)位的值就是将(i)二进制翻转之后的(a)（类似于(FFT)的蝴蝶操作）

//quming
#include<bits/stdc++.h>
#define R register
#define pb emplace_back
#define fi first
#define se second
#define gg return puts("NO"),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 pair<int,int> pi;
const int N=25,L=(1<<18)+5;
int low[L],hig[L],r[L],val[L];
vector<pi>vc[L];int n,lim;
priority_queue<pi,vector<pi>,greater<pi> >q;
int main(){
	scanf("%d",&n),lim=(1<<n);
	fp(i,0,lim-1){
		scanf("%d",&val[i]),--val[i];
		r[i]=(r[i>>1]>>1)|((i&1)<<(n-1));
	}
	fd(i,lim-1,0){
		hig[i]=(~val[i]?val[i]:lim-1);
		fp(k,0,n-1)if(i>>k&1^1)cmin(hig[i],hig[i|(1<<k)]);
	}
	fp(i,0,lim-1){
		if(~val[i])low[i]=val[i];
		fp(k,0,n-1)if(i>>k&1)cmax(low[i],low[i^(1<<k)]);
	}
	fp(i,0,lim-1){
		if(low[i]>hig[i])gg;
		vc[low[i]].pb(pi(hig[i],i));
	}
	fp(i,0,lim-1){
		for(auto v:vc[i])q.push(v);
		if(q.empty()||q.top().fi<i)gg;
		val[q.top().se]=i,q.pop();
	}
	puts("YES");
	fp(i,0,lim-1)printf("%d ",val[r[i]]+1);
	return 0;
}

(J)

据说可以直接点分暴艹……

就是对于当前点分中心，找到连上的边边权最小的那个点，再把当前连通块中所有点和那个点连边，最后跑一遍(kruskal)即可

//quming
#include<bits/stdc++.h>
#define R register
#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 long long ll;
const int N=2e5+5;
struct node{
	int u,v;ll w;
	inline node(R int uu,R int vv,R ll ww):u(uu),v(vv),w(ww){}
	inline bool operator <(const node &b)const{return w<b.w;}
};vector<node>E;vector<int>st;
struct eg{int v,nx,w;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v,R int w){e[++tot]={v,head[u],w},head[u]=tot;}
ll dis[N];int sz[N],vis[N],mx[N],fa[N],a[N];
int n,rt,size;
inline int find(R int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
void findrt(int u,int fa){
	sz[u]=1,mx[u]=0;
	go(u)if(!vis[v]&&v!=fa){
		findrt(v,u);
		sz[u]+=sz[v],cmax(mx[u],sz[v]);
	}
	cmax(mx[u],size-sz[u]);
	if(mx[u]<mx[rt])rt=u;
}
void get(int u,int fa){
	st.pb(u);
	go(u)if(!vis[v]&&v!=fa)dis[v]=dis[u]+e[i].w,get(v,u);
}
void solve(int u){
	vis[u]=1,dis[u]=0,st.clear(),get(u,0);
	R int p=0;R ll mn=1e18;
	for(auto v:st)if(cmin(mn,dis[v]+=a[v]))p=v;
	for(auto v:st)E.pb(node(p,v,dis[p]+dis[v]));
	R int s=size;
	go(u)if(!vis[v]){
		rt=0,size=(sz[v]<=sz[u]?sz[v]:s-sz[u]);
		findrt(v,0),solve(rt);
	}
}
int main(){
	scanf("%d",&n),mx[0]=n+1;
	fp(i,1,n)scanf("%d",&a[i]);
	for(R int i=1,u,v,w;i<n;++i){
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w),add(v,u,w);
	}
	rt=0,size=n,findrt(1,0),solve(rt);
	sort(E.begin(),E.end());
	fp(i,1,n)fa[i]=i;
	R ll res=0;
	for(auto e:E)if(find(e.u)!=find(e.v))res+=e.w,fa[find(e.u)]=find(e.v);
	printf("%lld
",res);
	return 0;
}