Codeforces Round 319 # div.1 & 2 解题报告

标签：

Div. 2

Multiplication Table (577A)

题意：

给定n行n列的方阵，第i行第j列的数就是i*j，问有多少个格子上的数恰为x。

1<=n<=10^5, 1<=x<=10^9

题解：

送分题…对于每一行，判断是否存在数x即可…也可以枚举x的因子判断是否出现在表内…

#include<cstdio>#include<cstring>inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}int n,i,x,ans;int main(){
	n = read(); x = read();for(i=1;i<=n;i++)if(x%i==0)if(x/i<=n) ans++;
	printf("%d\n",ans);return0;}

Modulo Sum (577B)

题意：

给定长度为n的数列，判断是否存在和可以被m整除的子序列

1<=n<=10^6, 2<=m<=10^3, 0<=ai<=10^9

题解：

其实我看到这个数据范围以为是暴力的…

结果确实很多人拿O(nm)的暴力过了（只能说CF的评测机太快了）

我一开始写的是用bitset压位暴力，

用b[i]表示可以得到余数i，那么加入一个新的数就可以把所有为1的b[i]转移到b[(i+a[x])%m]，

于是我就拿bitset的位运算来做…

（既然别人暴力都过了，我的暴力当然也能过去，其实复杂度上来看也是可以过的）

不过其实并不用考虑大数据…

考虑前缀和（这题求的是子序列而不是子段，但是显然子段也是一个子序列，存在子段也代表答案是YES）

我们知道模m的剩余系大小为m，根据抽屉原理，当n>=m+1时，必定有两个元素关于模m同余。

而如果前缀和中 sum[l] ≡ sum[r] (mod m)，说明子段(l,r]就是满足条件的子序列。

所以只要n>m，答案就是YES。

所以实际复杂度就降为O(m^2)了

#include<cstdio>#include<cstring>#include<bitset>usingnamespace std;inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}int n,m,i,a[1010];
bitset<1024> bs,tmp;bool sol(){if(n>m)return1;for(i=1;i<=n;i++){
		tmp = bs<<a[i];
		bs |= bs>>(m-a[i]);
		bs |= tmp;
		bs[a[i]]=1;if(bs.test(0))return1;}return0;}int main(){	n = read(); m = read();if(n<=m)for(i=1;i<=n;i++) a[i]= read()%m;
	printf(sol()?"YES\n":"NO\n");return0;}

Div. 1

Vasya and Petya‘s Game (576A) (577C)

题意：

未知整数x∈[1,n]，每次询问可以知道x是否被某数y整除，问最少需要问多少次才可以确定x的具体数值。

1<=n<=10^3

题解：

我自己的做法是，

从小到大遍历1~n里的每一个数，

如果它的因子中所有被询问的数的最小公倍数t不等于自身，则说明需要询问这个数。

因为如果t等于自身，所有询问结果都是“是”的情况就可以唯一确定这个数。

否则就无法区分t与当前数。

而官方题解的做法是，因为如果不询问p^k就无法区分p^(k-1)和p^k，所以每个p^k(k>0)都要询问。

后来我仔细想了一下，这两个做法其实是等价的。

因为因子中所有被询问的数的最小公倍数不等于自身的，只有底数为质数的幂。

具体来说的话，

1、显然质数是要询问的

2、当前数为合数，且是底数为质数的幂

如果当前数是p^a，因为只有形如p^b (b|a, b<a) 的因子，

所以它们的最小公倍数一定小于p^a，也就是说p^a要被询问。

3、当前数为合数，且不是底数为质数的幂

根据算术基本定理，合数n可以表示成 p1^a1 * p2^a2 * … * pk^ak，

显然 p1^a1、p2^a2…pk^ak 两两互质。

又因为所有pi^ai会被询问，所以这些数的最小公倍数一定就是n本身，

所以此时不用询问。

回到这题，只要筛出素数，并输出它的幂即可。

复杂度O(n)

#include<cstdio>#include<cstring>int n,i,j,s,t,tt,a[1003],pr[1003],ps;bool b[1003];int main(){	scanf("%d",&n); s =0;for(i=2;i<=n;i++){if(!b[i]){
			pr[++ps]= i;for(j=i;j<=n;j*=i) a[++s]= j;}for(j=1;j<=ps&&i*pr[j]<=n;j++){
			b[i*pr[j]]=1;if(i%pr[j]==0)break;}}
	printf("%d\n",s);for(i=1;i<s;i++) printf("%d ",a[i]);if(s) printf("%d\n",a[s]);return0;}

Invariance of Tree (576B) (577D)

题意：

给定长为n的序列p1..pn，要求输出一棵树满足：u与v相连 当且仅当 p[u]与p[v]相连

有解输出YES和任意一个解的树上的所有边，无解输出NO。

1<=n<=10^5

题解：

构造…

这题的突破口就是题目名字…

重点在于找到可行解中进行置换后不变的东西。

（不变的是一个点）如果存在一个数a=p[a]，那么把所有其它点连到这个点就是一个可行解。

（不变的是一条边）也就是说存在两个数，满足a=p[a]且b=p[b]。这个时候的情况会稍微复杂一点。

因为虽然这条边不动，但是两个端点交换了位置，如果边的两端点的子树不同，置换后就不满足要求。

所以同时要满足这条边两端子树中的节点也恰好交换位置。

所以可以找到每一个环，

把环上奇数位置的点连到a，偶数位置的连到b（置换后ab互换，同时这些点也互换位置）

不过这样做，在存在奇数个元素的环的时候就不行了，这时无法构造。

（注意这时如果存在第一种情况的构造就可以按照第一种情况来）

#include<cstdio>#include<cstring>inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}constint N =100010;int n,i,j,nx[N],st,st2,l,tmp,ev;bool b[N];int main(){	n = read();for(i=1;i<=n;i++) nx[i]= read();
	l =-1; ev =1;for(i=1;i<=n;i++){for(j=i,tmp=0;!b[j];j=nx[j],tmp++) b[j]=1;if(l!=1&&tmp==1) st = i, l =1;if(l==-1&&tmp==2) st = i, st2 = nx[i], l =2;if(tmp&1) ev =0;}if(l==-1||(l==2&&!ev)) printf("NO\n");else{
		printf("YES\n");if(l==1){for(i=1;i<=n;i++)if(i!=st) printf("%d %d\n",st,i);}else{
			printf("%d %d\n",st,st2);
			memset(b,0,sizeof b);for(i=1;i<=n;i++){if(i==st||i==st2)continue;for(j=i,tmp=0;!b[j];j=nx[j],tmp^=1) b[j]=1, printf("%d %d\n",j,tmp?st2:st);}}}return0;}

Points on Plane (576C) (577E)

题意：

给定n个点，求一条经过所有点的路径，它的总曼哈顿距离<25*10^8

1<=n<=10^6, 0<=x,y<=10^6

题解：

完全的乱搞题…一开始感觉无从下手…样例也是用来搞笑的…

正确的做法是按照[x/1000]分块…每块中按照y坐标排序…

然后交替从高到低、从低到高地走，然后就构造出答案了。

#include<cstdio>#include<cstring>#include<algorithm>#include<vector>usingnamespace std;typedeflonglong lint;constint N =1000010;
lint x[N],y[N],i,j,n;bool p;
vector<int> vct[1010];
vector<int>::iterator it;
vector<int>::reverse_iterator rit;inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}inlineint abs(int a){return a>0?a:-a;}bool cmp(constint&a,constint&b){return y[a]<y[b];}int main(){	n = read();for(i=1;i<=n;i++){
		x[i]= read(), y[i]= read();
		vct[x[i]/1000].push_back(i);}for(i=0;i<=1000;i++){if(vct[i].empty())continue;
		p^=1;
		sort(vct[i].begin(),vct[i].end(),cmp);if(p)for(rit=vct[i].rbegin();rit!=vct[i].rend();rit++) printf("%d ",(*rit));elsefor(it=vct[i].begin();it!=vct[i].end();it++) printf("%d ",(*it));}return0;}

Flights for Regular Customers (576D)

题意：

给定一个有向图，图上的边有限制条件，必须满足经过的边数（包括相同）达到限制条件才可以同行。

存在自环。

2<=n<=150, 1<=m<=150

题解：

150…想想发现好像不是网络流…

嗯就DP好了。f[i][j]表示i步后能否在j这个点。

很显然这个DP可以用转移矩阵跑快速幂来弄…

然后对于从小到大的每个限制条件，

如果满足较大的条件时仍然不能到达，那么只满足较小的条件时也一定不能到达。

看到这种性质…我就直接二分了…然而因为转移时也有m的因子，所以二分没什么用…

于是写了从小到大枚举满足的条件，如果满足后能够到达，就在这一个条件和下一个条件之间二分…

然后就有了复杂度爆炸的解法…被卡了很多次…尽管是CF上的4s…

主要有两点优化，都是在矩阵乘法时优化，（因为矩阵是01矩阵所以可以优化）

一个是改变矩阵乘法时的循环顺序，改为i-k-j循环，那么如果a[i][k]==0，则所有a[i][k]&b[k][j]都是0，这时可以continue掉…

另一个是在上面加上bitset…等于直接压位然后位运算来算矩阵了…

（其实加上第一个之后我就已经1s内过了）

#include<cstdio>#include<cstring>#include<algorithm>#include<bitset>usingnamespace std;inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}constint N =155;typedef bitset<N> bs;int n,m,i,j,po,l,r,mid,stp[N],dt,ie,ans,ymd;struct eg{int aa,bb,d;}e[N];struct mrx{
	bs nu[150];void clr(){ memset(nu,0,sizeof nu);}friend mrx operator*(const mrx &a,const mrx &b){
		mrx c; c.clr();for(int i=0;i<n;i++)for(int k=0;k<n;k++)if(a.nu[i][k])
				c.nu[i]|= b.nu[k];return c;}}ym,tm,sm,tmp;bool cmp(const eg &a,const eg &b){return a.d<b.d;}
mrx powmrx(mrx a,int b){
	mrx ans; ans.clr();for(int i=0;i<n;i++) ans.nu[i][i]=1;for(;b;b>>=1){if(b&1) ans = ans*a;
		a = a*a;}return ans;}void sol(int curp){
	l =0; r = e[stp[curp+1]].d-e[stp[curp]].d-1;while(l<=r){
		mid =(l+r)>>1;
		sm = ym*powmrx(tm,mid);if(sm.nu[0][n-1])
			ans = mid, r = mid-1;else
			l = mid+1;}}int main(){#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);#endif
	n = read(); m = read();for(i=1;i<=m;i++) e[i].aa = read(), e[i].bb = read(), e[i].d = read();
	std::sort(e+1,e+1+m,cmp);
	e[0].d =-1;for(i=1;i<=m;i++)if(e[i].d!=e[i-1].d) stp[++dt]= i;
	e[stp[dt+1]= m+1].d =1000000000+n;
	po =1; tm.nu[n-1][n-1]=1; ym.nu[0][0]=1;
	ans =-1;if(e[1].d==0)for(i=1;i<=dt;i++){for(j=stp[i],ie=stp[i+1];j<ie;j++) tm.nu[e[j].aa-1][e[j].bb-1]=1;
			tmp = ym*powmrx(tm,e[stp[i+1]].d-e[stp[i]].d);if(tmp.nu[0][n-1]){
				sol(i);if(ans!=-1){ ans += e[stp[i]].d;break;}}
			ym = tmp;}if(ans==-1) printf("Impossible\n");else printf("%d\n",ans);return0;}

Painting Edges (576E)

题意：

给定n点m边的无向图，有q次询问，k种颜色。

对于每个询问，如果操作后对应颜色能够构成二分图，则改变颜色并输出YES

否则不改变颜色，并输出NO

2<=n<=10^5

1<=m,q<=10^5

1<=k<=50

题解：

线段树+暴力维护并查集…

并查集维护的方法就是维护奇偶性。在不同集合之间的边显然可以，同一集合内奇偶性不同的边也可以。

用线段树存所有的询问。题目最大的难点在于某种颜色对应的边被删除…

换一种角度看，就是这条边的颜色会保持到下次改变这条边之前。

所以拿线段树来暴力维护并查集状态就好了…

求答案就是按1~q在线段树的叶节点跑。

（这种维护并查集不能路径压缩，所以要按秩合并，否则超时非常严重）

（深深地体会到了这种差别）

#include<cstdio>#include<cstdlib>#include<cstring>#include<algorithm>#include<vector>usingnamespace std;constint N =500003;typedef pair<int,int> pii;int n,m,i,j,k,Q,ql,qr,qc,qe,nx[N],tnx[N],rcol[N];
pii e[N],q[N];
vector<pii> mgv[1100000];struct revdt
{int c,p,f,z,s;
	revdt(int _c,int _p,int _f,int _z,int _s){c=_c,p=_p,f=_f,z=_z,s=_s;}};typedef vector<revdt> revvct;struct revdsu
{int f[N],z[N],s[N];
	pii findf(int a){int ss=0;while(a!=f[a]) ss^= s[a], a = f[a];return make_pair(a,ss);}bool dis(int a,int b){return findf(a)!=findf(b);}void merge(int a,int b,int col,revvct &vct){
		pii pa = findf(a), pb = findf(b);int fa = pa.first, fb = pb.first;if(fa==fb)return;bool fl =0;if(z[fa]==z[fb]) z[fa]++, fl =1;if(z[fa]>z[fb]) swap(fa,fb);
		vct.push_back(revdt(col,fa,f[fa],z[fa]-(fl?1:0),s[fa]));
		f[fa]= fb; s[fa]= pa.second^pb.second^1;}}osu[51]; //osu是来卖萌的inlineint read(){int s =0;char c;while((c=getchar())<‘0‘||c>‘9‘);do{s=s*10+c-‘0‘;}while((c=getchar())>=‘0‘&&c<=‘9‘);return s;}void add(int p,int l,int r){if(ql<=l&&r<=qr){
		mgv[p].push_back(make_pair(qc,qe));return;}int m =(l+r)>>1;if(ql<=m) add(p+p,l,m);if(qr>m) add(p+p+1,m+1,r);}void query(int p,int l,int r){
	revvct vct;for(vector<pii>::iterator it=mgv[p].begin();it!=mgv[p].end();it++)
		osu[it->first].merge(e[it->second].first,e[it->second].second,it->first,vct);if(l>=r){
		qe = q[l].first;int a = e[qe].first, b = e[qe].second, co = q[l].second;if(osu[co].dis(a,b)) printf("YES\n"), rcol[qe]= co;else printf("NO\n");
		ql = l+1, qr = nx[l]-1, qc = rcol[qe];if(rcol[qe]) add(1,1,Q);}else{int m =(l+r)>>1;
		query(p+p,l,m);
		query(p+p+1,m+1,r);}while(!vct.empty()){
		revdt it = vct.back();
		osu[it.c].f[it.p]= it.f;
		osu[it.c].z[it.p]= it.z;
		osu[it.c].s[it.p]= it.s;
		vct.pop_back();}}int main(){#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);#endif
	n = read(); m = read(); k = read(); Q = read();for(i=1;i<=n;i++)for(j=1;j<=k;j++) osu[j].f[i]= i;for(i=1;i<=m;i++) e[i].first = read(), e[i].second = read(), tnx[i]=Q+1;for(i=1;i<=Q;i++) q[i].first = read(), q[i].second = read();for(i=Q;i;i--){ nx[i]= tnx[q[i].first]; tnx[q[i].first]= i;}
	query(1,1,Q);return0;}

Codeforces Round 319 # div.1 & 2 解题报告

标签：

原文地址：http://www.cnblogs.com/meowww/p/4982523.html