AtCoder Grand Contest 012题解

\(A\)

肯定是后面每两个陪最前面一个最优

typedef long long ll;
const int N=5e5+5;
int a[N],n;ll res;
int main(){
	scanf("%d",&n);
	fp(i,1,n*3)scanf("%d",&a[i]);
	sort(a+1,a+1+n*3);
	for(R int i=n+1;i<=n*3;i+=2)res+=a[i];
	printf("%lld\n",res);
	return 0;
}

\(B\)

首先染色肯定是后面的覆盖前面的，那么我们从后往前做，并对每个点记录\(d_i\)从这个点还能延伸多少，只有当\(d_i\)增大的时候才考虑从它开始更新，因为所有的\(d\)都很小，所以每个点被更新不会超过\(d_i\)次，总复杂度为\(O(d_in)\)

//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;
struct eg{int v,nx;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v){e[++tot]={v,head[u]},head[u]=tot;}
struct node{int u,d,c;}E[N];
int d[N],c[N],q[N],n,m,Q;
void solve(int S,int dis,int col){
	int h=1,t=0,u;
	q[++t]=S;
	while(h<=t){
		u=q[h++];if(!c[u])c[u]=col;
		go(u)if(cmax(d[v],d[u]-1))q[++t]=v;
	}
}
int main(){
	scanf("%d%d",&n,&m);
	fp(i,1,n)d[i]=-1;
	for(R int i=1,u,v;i<=m;++i)scanf("%d%d",&u,&v),add(u,v),add(v,u);
	scanf("%d",&Q);
	fp(i,1,Q)scanf("%d%d%d",&E[i].u,&E[i].d,&E[i].c);
	fd(i,Q,1)if(cmax(d[E[i].u],E[i].d))solve(E[i].u,E[i].d,E[i].c);
	fp(i,1,n)printf("%d\n",c[i]);
	return 0;
}

\(C\)

让最终的序列长成形如\(p_1,p_2,p_3,...,p_n,1,2,3,...,n\)的形式，那么发现合法的子序列个数就是\(p\)中递增子序列个数\(-1\)

那么我们\(++n\)，然后用一个类似倍增的思想来维护。发现空集时递增子序列个数为\(1\)，在后面加上\(n+1\)子序列个数\(\times 2\)，在前面加上\(n+1\)子序列个数\(+1\)

用双端队列维护一下就好了

//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;
deque<int>st;ll n,k;int pos;
int main(){
	scanf("%lld",&n);++n;
	while((1ll<<pos)<=n)++pos;
	fd(i,pos-2,0){
		st.push_back(++k);
		if(n>>i&1)st.push_front(++k);
	}
	printf("%d\n",k<<1);
	fp(i,0,k-1)printf("%d ",st[i]);
	fp(i,1,k)printf("%d ",i);
	return 0;
}

\(D\)

首先，我们发现如果能交换\(ab\)和\(ac\)，那么可以在不改变其他位置的情况下交换\(bc\)，所以如果我们把所有可以交换的连一条边，则一个连通块中所有的点都可以互换位置，连通块内部的答案直接算就可以了

然后考虑连边，对于每个点\(u\)，设它这种颜色对应的重量最小的点为\(mn\)，有两种情况\(u\)能和\(mn\)联通，一种是直接连边，一种是找到一个与它们颜色不同的\(v\)然后连边\((u,v)\)和\((v,mn)\)。那么如果\(u\neq mn\)且能直接连边就连边，否则找到一个与它们颜色不同且重量最小的点\(v\)尝试与它连边。不难发现最终所有连过边的点都和重量最小的点在同一个连通块中，那么计算一下就行了

//quming
#include<bits/stdc++.h>
#define R register
#define fi first
#define se second
#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=2e5+5;
typedef pair<int,int> pi;
int fac[N],ifac[N],fa[N],mn[N],cnt[N];pi c[N];
int n,x,y,pos,sz,res;
inline int find(R int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
int main(){
	scanf("%d%d%d",&n,&x,&y);
	fp(i,1,n)scanf("%d%d",&c[i].se,&c[i].fi);
	sort(c+1,c+1+n);
	pos=2;
	while(pos<=n&&c[pos].se==c[1].se)++pos;
	if(pos>n)return puts("1"),0;
	fd(i,n,1)mn[c[i].se]=i,fa[i]=i;
	fd(i,n,1){
		if(i!=mn[c[i].se]&&c[i].fi+c[mn[c[i].se]].fi<=x)
			fa[find(i)]=find(mn[c[i].se]);
		else if(c[i].se!=c[1].se&&c[i].fi+c[1].fi<=y)
			fa[find(i)]=find(1);
		else if(c[i].se!=c[pos].se&&c[i].fi+c[pos].fi<=y)
			fa[find(i)]=find(pos);
	}
	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);
	fp(i,1,n)if(find(i)==find(1))++sz,++cnt[c[i].se];
	res=fac[sz];
	fp(i,1,n)res=mul(res,ifac[cnt[i]]);
	printf("%d\n",res);
	return 0;
}

\(F\)

感觉司公子说的比\(yyb\)说的好懂一点……那我这里就说一下司公子的写法吧……

方便起见先默认\(a_i=i\)

首先，显然\(i\leq b_i\leq 2n-i\)

其次，我们考虑加入两个新的数字，那么中位数要么不变，要么变成前驱或者后继

所以会有两个性质

\(1.i\leq b_i\leq 2n-i\)

\(2.\)，不存在\(i<j\)，使得\(b_j<b_i<b_{j+1}\)或者\(b_j>b_i>b_{j+1}\)

我们可以认为假设有一个\(S\)表示所有合法的\(b_i\)的取值的集合，首先肯定有\(b_n=n\)，那么如果我们倒着构造\(b\)，且正在考虑到\(b_i\)，第一个性质代表我们可以往\(S\)中加入\(i\)和\(2n-i\)，第二个性质说明如果选定了\(b_i\)，那么\(S\)中所有值在\(b_i\)和\(b_{i+1}\)之间的数（不含端点）都应该被删去（因为根据性质\(2\)显然前面的数中是不能存在这样的数的）

\(ps:\)或者上面的第二点也可以理解为，如果\(b_{i}\neq b_{i+1}\)说明\(b_{i+1}\)必定是前\(2i+1\)个数中\(b_i\)的前驱或后继，那么在它们区间内的数显然会妨碍它们成为前驱或后继，所以在\(a\)中都不能存在

然后我们来考虑一下，按照上面这个规则构造出来的\(b\)是否全部合法，也就是说\(S\)里面所有的数只有一个必要性，如何证明它们的充分性

考虑从\(b_{i+1}\)到\(b_i\)的过程，如果\(b_{i+1}>b_i\)，那么我们删去前\(2i+1\)个数中比\(b_{i+1}\)大的最小的两个数，那么我们可以取到合法的\(b_i\)的最小值，同理如果\(b_{i+1}<b_i\)可以取到最大值，而\(b_{i}=b_{i+1}\)的话，我们只要删掉前\(2i+1\)个数中比\(b_i\)大的最小的数和比\(b_i\)小的最大的数就可以取到最大最小值了

然后接下来就是计算方案了，记\(f[i][j][k]\)表示倒序考虑\(b\)，考虑了\(i\)个数，合法的取值个数为\(j\)，且取了这些值中第\(k\)个的方案数，转移枚举一下下一个数取了合法取值中第几个就行了

记得有一个问题就是实际上\(a\)可能会有相等的情况，那么性质一能不能拓展要看情况

说真的还是看代码比较好理解……

//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;
int a[N],f[N][N][N],n,res;
int main(){
	scanf("%d",&n);
	fp(i,1,n+n-1)scanf("%d",&a[i]);
	sort(a+1,a+n+n);
	f[1][1][1]=1;
	fp(i,1,n-1)fp(j,1,n+n-1)fp(k,1,j)if(f[i][j][k]){
		R int tj=j,tk=k;
		if(a[n+i]!=a[n+i-1])++tj;
		if(a[n-i]!=a[n-i+1])++tj,++tk;
		fp(h,1,tj){
			if(h<tk)upd(f[i+1][tj-(tk-h-1)][h],f[i][j][k]);
			if(h>tk)upd(f[i+1][tj-(h-tk-1)][tk+1],f[i][j][k]);
			if(h==tk)upd(f[i+1][tj][h],f[i][j][k]);
		}
	}
	fp(i,1,n+n-1)fp(j,1,i)upd(res,f[n][i][j]);
	printf("%d\n",res);
	return 0;
}