Codeforces 1103 简要题解（持续更新）

版权声明：随意转载哦......但还是请注明出处吧： https://blog.csdn.net/dreaming__ldx/article/details/86604928

传送门
又一场原地爆炸的比赛。
$A$题简单思维
题意：给一个 $4*4$的格子图和一个01串，你要根据01串放 $1*2$的木块，如果是0就竖放一个，是1就横放一个，一行或者一列满了可以直接消掉。
现在让你每次输出放下木块的坐标，并保证所有操作中没有木块相交。

---

思路：
可以直接按照自己的思路模拟然后我这个sb想了好久用什么策略
下来之后突然想到一个更简单的做法，我们保证如果竖放先放 $(1,1)$，如果横放先放 $(4,4)$，这样接下来无论是横放还是竖放都会消掉之前放过的一个。
比赛代码（丑：

#include<bits/stdc++.h>
#define ri register int
#define fi first
#define se second
using namespace std;
inline int read(){
	int ans=0;
	char ch=getchar();
	while(!isdigit(ch))ch=getchar();
	while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
	return ans;
}
char s[1005];
int n,vis[5][5];
inline void update(){
	for(ri i=1;i<=4;++i)if(vis[i][1]&&vis[i][2]&&vis[i][3]&&vis[i][4])vis[i][1]=vis[i][2]=vis[i][3]=vis[i][4]=0;
	for(ri i=1;i<=4;++i)if(vis[1][i]&&vis[2][i]&&vis[3][i]&&vis[4][i])vis[1][i]=vis[2][i]=vis[3][i]=vis[4][i]=0;
}
inline void find(int type){
	if(!type){
		for(ri j=1;j<=4;++j)for(ri i=1;i<=3;++i){
			if(!vis[i][j]&&!vis[i+1][j]){
				vis[i][j]=vis[i+1][j]=1;
				cout<<i<<' '<<j<<'\n';
				return update();
			}
		}
	}
	else{
		for(ri i=1;i<=4;++i)for(ri j=1;j<=3;++j){
			if(!vis[i][j]&&!vis[i][j+1]){
				vis[i][j]=vis[i][j+1]=1;
				cout<<i<<' '<<j<<'\n';
				return update();
			}
		}		
	}
}
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	for(ri i=1;i<=n;++i)find(s[i]-'0');
	return 0;
}

---

$B$题 二分好题 交互题
题意简述：你需要通过不超过60次询问来猜一个数 $a,a\le1e9$，每次可以问两个数 $x,y$，如果 $(x\mod a)\ge (y\mod a)$会返回 $0$否则返回 $1$

---

思路：
我们考虑倍增求出 $a$的范围然后再二分求 $a$的准确值。
最开始先让 $x=0,y=1$然后问，如果返回 $1$就说明 $a$不在区间 $(x,y]$里，那么令 $x=y,y=y*2+1$继续问下去知道返回 $0$位置。
返回 $0$时说明 $a$的取值在 $(x,y]$之间，那么我们二分 $a$的值一直问 $x,mid$来缩小范围即可。
代码：

#include<bits/stdc++.h>
#define ri register int
#define fi first
#define se second
using namespace std;
inline int read(){
	int ans=0;
	char ch=getchar();
	while(!isdigit(ch))ch=getchar();
	while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
	return ans;
}
char s[6];
typedef long long ll;
int main(){
	while(scanf("%s",s)){
		if(s[0]=='e')break;
		if(s[0]=='m')break;
		ll x=0,y=1;
		while(cout<<"? "<<x<<' '<<y<<endl,fflush(stdout),scanf("%s",s),s[0]=='y'){
			x=y,y=x*2+1;
		}
		if(s[0]=='e')break;
		ll l=x+1,r=y,ans=y;
		while(l<=r){
			ll mid=l+r>>1;
			bool f;
			cout<<"? "<<x<<' '<<mid<<endl,fflush(stdout),scanf("%s",s),f=s[0]=='x';
			if(s[0]=='e')break;
			if(f)r=mid-1,ans=mid;
			else l=mid+1;
		}
		cout<<"! "<<ans<<endl;
		fflush(stdout);
	}
	return 0;
}

---

$C$题 图论好题
题意简述：给一张无重边自环的无向图，每个点度数至少为3，现在给出 $k$，要求你构造出以下两类答案中的任意一种：

1. 找到一条路径，使得其长度 $\ge\frac nk$
2. 找到 $k$个环，使得每个环长度至少为 $3$且不为 $3$的倍数，且每个环中至少有一个点在所有输出的环中只出现过一次。

---

思路：
我们先 $dfs$构造出图的一个生成树，这个时候如果闲的胃疼可以求一遍直径去构造第一类答案，也可以直接枚举每个点的深度来判断能不能简单构造，如果不行就直接去构造多个环的答案。
然后考虑如何构造出多个环的答案，在生成树上面每个数的深度都不能满足条件的时候说明至少有 $k$个 叶子结点，由于每个点度数至少为 $3$，因此这个叶子结点除了连接父亲的树边以外还存在跟自己祖先连接的两条非树边 注意这里说的是祖先，因为如果不是祖先的话dfs的时候会走过去，它就不是叶子节点了
然后说明至少有两个环，且这个叶子结点可以当做那个在所有环中只出现过一次的特殊点。
然后可以用如下方法构造答案。

1. 两个环中至少有一个长度不是 $3$的倍数，直接输出这个环。
2. 两个环的长度都是 $3$的倍数，那么设离当前叶子结点近的点是 $y$，原的是 $x$，叶子结点是 $z$，我们把 $y->x$路径上所有点和 $z$拿来构造成一个环，这个环的长度是 $3k+1$满足题意。

代码（略丑：

#include<bits/stdc++.h>
#define ri register int
using namespace std;
inline int read(){
	int ans=0;
	char ch=getchar();
	while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
	return ans;
}
const int N=250005,M=5e5+5;
int n,m,k,dep[N],fa[N];
bool leaf[N],vis[N];
vector<int>e[N];
void dfs(int p){
	leaf[p]=vis[p]=1;
	for(ri i=0,v;i<e[p].size();++i){
		if(vis[v=e[p][i]])continue;
		leaf[p]=0,dep[v]=dep[p]+1,fa[v]=p,dfs(v);
	}
}
int main(){
	n=read(),m=read(),k=read();
	for(ri i=1,u,v;i<=m;++i)u=read(),v=read(),e[u].push_back(v),e[v].push_back(u);
	dep[1]=1,dfs(1);
	int tmp=(n+k-1)/k;
	for(ri i=1;i<=n;++i){
		if(dep[i]>=tmp){
			puts("PATH");
			printf("%d\n",dep[i]);
			while(i){
				printf("%d ",i);
				i=fa[i];
			}
			return 0;
		}
	}
	puts("CYCLES");
	vector<int>pos;
	for(ri i=1;i<=n&&pos.size()<k;++i)if(leaf[i])pos.push_back(i);
	for(ri i=1,p;i<=k;++i){
		bool f=0;
		p=pos[i-1];
		for(ri j=0,v;j<e[p].size();++j){
			if((v=e[p][j])!=fa[p]&&(dep[p]-dep[v]+1)%3){
				printf("%d\n",dep[p]-dep[v]+1),f=1;
				while(fa[p]!=fa[v]){
					printf("%d ",p);
					p=fa[p];
				}
				printf("%d",p);
				puts("");
				break;
			}
		}
		if(f)continue;
		vector<int>bad;
		for(ri j=0,v;j<e[p].size()&&bad.size()<2;++j)if((v=e[p][j])!=fa[p])bad.push_back(v);
		int x=bad[0],y=bad[1];
		if(dep[x]>dep[y])swap(x,y);
		printf("%d\n",dep[y]-dep[x]+2);
		printf("%d ",p);
		while(fa[x]!=fa[y]){
			printf("%d ",y);
			y=fa[y];
		}
		printf("%d",y);
		puts("");
	}
	return 0;
}

---

$D$题 状压dp好题
题意简述：给 $n$个二元组和一个 $k$。
二元组 $(a_i,e_i)$表示第 $i$个位置的权值是 $a_i$，贡献是 $e_i$。
现在对于每个位置可以让它的权值除以它自己一个不超过 $k$的约数，要求从 $n$个数中选择若干个数出来，使得它们的权值在除以约数过后的 $gcd$为 $1$，花费的代价是选出来的选择数的个数乘上选出来的所有数的贡献和。
数据范围： $n\le1e5,k,a_i\le1e12$

---

思路：
考虑到 $gcd$的范围也是 $[1,1e12]$，不难证明这个 $gcd$最多有不超过 $12$个不同的质因子。
先思考一个问题：怎么去除自己的约束最优？
我们先令 $gcd=a_1^{p_1}a_2{p^2}...a_k^{p_k}$
显然对于一个要计入答案的数 $val$，只用关心它和 $gcd$都有的质因数。
所以令 $val=t*a_1^{q_1}a_2^{q_2}...a_k^{q_k}$，其中 $(t,a_1)=(t,a_2)=...=(t,a_k)=1$
那么对于这个数，我们选择它肯定就要它自己使得若干个幂次不为 $0$的质数幂全部去掉，否则不如不选它，即去掉 $a_1^{q_1},a_2^{q_2},...,a_k^{q_k}$中的至少一个 这里去掉的意思指的是用除法除掉，这样之后取gcd的时候如果选这个数这个被除掉的质数幂就不会算进去
这样一来，我们选出来的每个数至少会去掉一种之前没出现过的质数幂，因此最多选择不超过12个数就能够使得它们在除去质因子之后的 $gcd$为1。
于是可以设计状态 $f_{i,j}$表示现在已经去除的质因子的集合为 $i$，用了 $j$个数。
考虑先把所有相同的数并在一起（因为它们分解之后也是相同的）
转移的话可以先对于每个数预处理出另外一个 $dp$数组 $g$， $g_i$表示对于这个数要使得被除去的质数幂状态为 $i$所需的最小这个数的个数（因为把相同的并在一起所以每个数的个数不一定是1）。
然后再枚举子集转移就行了。
细节较多。
代码：

#include<bits/stdc++.h>
#define ri register int
using namespace std;
typedef long long ll;
inline ll read(){
	ll ans=0;
	char ch=getchar();
	while(!isdigit(ch))ch=getchar();
	while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
	return ans;
}
inline map<ll,int> solve(ll x){
	map<ll,int>ret;
	ret.clear();
	for(ll i=2;i*i<=x;++i)while(x%i==0)x/=i,++ret[i];
	if(x^1)++ret[x];
	return ret;
}
const ll inf=1e18;
const int N=(1<<12)+5,M=13,K=1e6+5;
int n,m;
ll k,a[K],b[K],gc,res=inf;
int main(){
	n=read(),k=read(),gc=0;
	for(ri i=1;i<=n;++i)gc=__gcd(a[i]=read(),gc);
	for(ri i=1;i<=n;++i)b[i]=read();
	map<ll,int>fac=solve(gc);
	vector<ll>divv;
	for(map<ll,int>::iterator it=fac.begin();it!=fac.end();++it)divv.push_back(it->first);
	m=divv.size();
	vector<ll>v(m);
	map<vector<ll>,vector<ll> >mp;
	for(ri i=1;i<=n;++i){
		for(ri j=0;j<m;++j){
			v[j]=1;
			while(a[i]%divv[j]==0)a[i]/=divv[j],v[j]*=divv[j];
		}
		mp[v].push_back(b[i]);
	}
	vector<vector<ll> >f(1<<m,vector<ll>(m+1,inf));
	f[0][0]=0;
	for(map<vector<ll>,vector<ll> >::iterator it=mp.begin();it!=mp.end();++it){
		vector<ll>mul=it->first,sum=it->second,g(1<<m,inf);
		sort(sum.begin(),sum.end());
		for(ri i=1;i<sum.size();++i)sum[i]+=sum[i-1];
		for(ri i=0;i<(1<<m);++i){
			ll mult=1;
			for(ri j=0;j<m;++j)if((i>>j)&1)mult*=mul[j];
			if(mult<=k)g[i]=1;
		}
		for(ri i=0;i<(1<<m);++i)for(ri j=i;j;j=(j-1)&i){if(j==i)continue;g[i]=min(g[i],g[i^j]+g[j]);}
		for(ri i=(1<<m)-1;~i;--i)for(ri j=i;j;j=(j-1)&i){
			if(g[j]>sum.size())continue;
			for(ll k=0;g[j]+k<=m;++k)f[i][k+g[j]]=min(f[i][k+g[j]],f[i^j][k]+sum[g[j]-1]);
		}
	}
	for(ri i=0;i<=m;++i)if(f[(1<<m)-1][i]^inf)res=min(res,f[(1<<m)-1][i]*i);
	cout<<(res==inf?-1:res);
	return 0;
}