Codeforces Round 1292 简要题解

最新推荐文章于 2021-01-05 21:31:33 发布

mayaohua2003

最新推荐文章于 2021-01-05 21:31:33 发布

阅读量619

点赞数

分类专栏： codeforces 构造动态规划

本文链接：https://blog.youkuaiyun.com/qq_38609262/article/details/106747244

版权

codeforces 同时被 3 个专栏收录

100 篇文章

订阅专栏

动态规划

47 篇文章

订阅专栏

构造

23 篇文章

订阅专栏

本文详细介绍了Codeforces Round 1292的题目，涉及A. NEKO's Maze Game、B. Aroma's Search、C. Xenon's Attack on the Gangs等五道题目。重点讲解了B题的解决方案，通过分解质因数和计算集合距离找到最优解，时间复杂度为O(k^2+n)。E题为智力题，通过精心设计的询问策略，确保在限定能量内解决问题，单组数据时间复杂度为O(n)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A. NEKO’s Maze Game

略

B. Aroma’s Search

略

C. Xenon’s Attack on the Gangs

略

D. Chaotic V.

vp的时候脑子抽了，不知道写了啥，最后也没过。
令 $k=\max(k_i)$ ，考虑将 $1!\sim k!$ 分解质因数，这里可以从小到大计算，每次在上次基础上分解最后一个数即可。将一个数 $x$ 表示为每个质因子出现次数的集合 $c_1,c_2,...,c_m)$ ，那么 $x$ 的父亲即为将第一个不为 $0$ 的 $c_i$ 减去 $1$ 后所得的集合，也可以方便计算两个集合间的距离。
注意到一定存在一个最优的 $P$ 是将某个 $x!$ 对应集合某个前缀变为 $0$ 所得到的，证明可以考虑对于某个 $P$ ，找到最接近（公共后缀最长）的 $x!$ 对应集合，那么显然需要满足最后一个不同的位 $p$ 之前都是 $0$ ，并且若位 $p$ 不为 $0$ ，那么显然可以选择变成一个与 $P$ 从 $p + 1$ 位往后都相同的 $y!$ 的对应集合的 $p$ 往后的后缀，且答案不会变劣。
这样就可以暴力枚举每个 $x!$ 的后缀作为可能的 $P$ 计算答案了，实现的时候考虑预处理出了阶乘之间的最长公共后缀（只需要枚举相邻两个暴力计算，然后取中间的 $\min$ 即可）以及一些前缀和，即可轻松从后往前计算答案。
时间复杂度为 $\mathcal O(k^2+n)$ 。

#include <bits/stdc++.h>
#define FR first
#define SE second
#define inf 0x3f3f3f3f3f3f3f3fLL

using namespace std;

typedef long long ll;
typedef pair<int,int> pr;

const int M=5000;

int prime[5005],tot;
bool check[5005];

int num[5005][1005],val[5005],trans[5005];
ll sum1[1005][5005],sum2[1005][5005],sum4[1005][5005],sum5[1005][5005],sum3[5005];

void pre() {
  for(int i=2;i<=M;i++) {
  	if (!check[i]) prime[++tot]=i;
  	for(int j=1;j<=tot&&i*prime[j]<=M;j++) {
  		check[i*prime[j]]=1;
  		if (i%prime[j]==0) break;
	  }
  }
  for(int i=1;i<=M;i++) {
  	memcpy(num[i],num[i-1],sizeof(num[i]));
  	int x=i;
  	trans[i]=1;
  	for(int j=1;j<=tot&&prime[j]<=i;j++) {
  		while (x%prime[j]==0) {
  			num[i][j]++;
  			x/=prime[j];
  			trans[i]=j+1;
		  }
	  }
  }
  for(int i=1;i<=tot;i++)
    for(int j=1;j<=M;j++) sum1[i][j]=sum1[i][j-1]+num[j][i];
  for(int i=1;i<=tot;i++)
    for(int j=1;j<=M;j++) sum2[i][j]=sum2[i-1][j]+sum1[i][j];
  for(int i=1;i<=tot;i++)
    for(int j=1;j<=M;j++) sum4[i][j]=sum4[i][j-1]+(ll)num[j][i]*val[j];
  for(int i=1;i<=tot;i++)
    for(int j=1;j<=M;j++) sum5[i][j]=sum5[i-1][j]+sum4[i][j];
  for(int i=1;i<=M;i++) sum3[i]=sum3[i-1]+val[i];
}

vector <int> vt[5005];

ll solve(int x,int n) {
  for(int i=1;i<=tot+2;i++) vt[i].clear();
  int maxn=1;
  for(int i=x-1;i>0;i--) {
  	maxn=max(maxn,trans[i+1]);
  	vt[maxn].push_back(i);
  }
  maxn=1;
  for(int i=x+1;i<=M;i++) {
  	maxn=max(maxn,trans[i]);
  	vt[maxn].push_back(i);
  }
  ll ans=inf,s1=0,s2=0;
  int lx=1,rx=M;
  for(int i=tot;i>0;i--) {
  	s2+=s1*num[x][i+1];
  	for(int j=0;j<vt[i+2].size();j++) {
  		int u=vt[i+2][j];
  		if (u<x) lx=max(lx,u+1); else rx=min(rx,u-1);
  		s1+=val[u];
		s2+=(sum2[i][u]-sum2[i][u-1])*val[u]+(ll)abs(num[u][i+1]-num[x][i+1])*val[u]; 
	  }
	ll s=s2+sum5[i-1][rx]-sum5[i-1][lx-1];
	ans=min(ans,s+sum4[i][rx]-sum4[i][lx-1]);
	if (i==1) {
		int v=num[x][i];
		s+=s1*v;
		s+=(sum3[x]-sum3[lx-1])*v-(sum4[i][x]-sum4[i][lx-1]);
		s+=(sum4[i][rx]-sum4[i][x])-(sum3[rx]-sum3[x])*v;
		ans=min(ans,s);
	}
  }
  return ans;
}

int main() {
  int n;
  scanf("%d",&n);
  for(int i=1;i<=n;i++) {
  	int x;
  	scanf("%d",&x);
  	if (!x) x=1;
  	val[x]++;
  }
  pre();
  ll ans=inf;
  for(int i=1;i<=M;i++)
    ans=min(ans,solve(i,n));
  printf("%lld\n",ans);
  return 0;
}

E. Rin and The Unknown Flower

人类智慧题。
考虑先问一遍 $^{'} C C^{'}$ , $^{'} C H^{'}$ 与 $^{'} C O^{'}$ ，这样可以知道所有不在第 $n$ 位的 $^{'} C^{'}$ 的位置与它们的后继。接着再问一下 $^{'} H O^{'}$ 与 $^{'} O H^{'}$ ，这样就可以知道所有相邻的 $^{'} H^{'}$ 与 $^{'} O^{'}$ 之间的变化了。那么现在考虑一个还不知道的非空极长连续段 $[l, r]$ （其中 $s_{l-1}$ 与 $s_{r+1}$ 存在且已知），那么必然有 $s_{l-1}\neq \ 'C'$ ，且容易推出 $s_{l-1}=s_l=\cdots=s_r$ 。同时，若此时存在已知位置，考虑最右边已知的位置为 $R$ ，那么显然有 $s_R=s_{R+1}=...=s_{n-1}$ 。这样，只有最左边一段和最右边一个位置（可能为 $^{'} C^{'}$ ）不一定知道了。注意到最左边一段只能全为 $^{'} H^{'}$ 或全为 $^{'} O^{'}$ ，问一次长为 $n - 1$ 的即可，而 $s_n$ 要么跟 $s_{n-1}$ 相等要么为 $^{'} C^{'}$ ，在问一次长为 $n$ 的即可。这样所需能量最大为 $\frac{5}{4}+\frac{1}{(n-1)^2}+\frac{1}{n^2}$ ，当 $n\geq 5$ 的时候不超过 $1.3525$ ，可以通过，但当 $n = 4$ 时会超过限制，考虑特殊构造。
考虑当 $n = 4$ 时减少长为 $2$ 的询问。先问一遍 $^{'} C H^{'}$ 与 $^{'} C O^{'}$ ，如果问出来至少一组的话直接暴力找剩下的。再问一遍 $^{'} H O^{'}$ 与 $^{'} O H^{'}$ ，问出来至少一组同样暴力找剩下的，都可以证明不会超过限制。如果仍然没问出来的话一定是 $k$ 个 $^{'} H^{'}$ （或 $k$ 个 $^{'} O^{'}$ ）后接 $n - k$ 个 $^{'} C^{'}$ ，那么考虑依次问 $^{'} C C C^{'}$ ， $^{'} H H H^{'}$ 和 $^{'} O O O^{'}$ ，如果问出来某一组的话也可以简单解决（可能要再问一次整个串），仍然没问出来的话只能是 $^{'} H H C C^{'}$ 或 $^{'} O O C C^{'}$ ，再问一次即可确定。这样所需能量最大约为 $1.3958$ ，可以通过。
单组数据时间复杂度为 $\mathcal O(n)$ 。

#include <bits/stdc++.h>
#define last last2

using namespace std;

vector<int> ask(string str) {
  cout<<"? "<<str<<endl;
  fflush(stdout);
  int k;
  cin>>k;
  vector<int> vt;
  for(int i=1;i<=k;i++) {
  	int x;
  	cin>>x;
  	vt.push_back(x);
  }
  return vt;
}

char ans[10005];

void solve_big(int n) {
  vector<int> vt;
  vt=ask("CC");
  for(int i=0;i<vt.size();i++) ans[vt[i]]=ans[vt[i]+1]='C';
  vt=ask("CO");
  for(int i=0;i<vt.size();i++) {
  	ans[vt[i]]='C';
  	ans[vt[i]+1]='O';
  }
  vt=ask("CH");
  for(int i=0;i<vt.size();i++) {
  	ans[vt[i]]='C';
  	ans[vt[i]+1]='H';
  }
  vt=ask("OH");
  for(int i=0;i<vt.size();i++) {
  	ans[vt[i]]='O';
  	ans[vt[i]+1]='H';
  }
  vt=ask("HO");
  for(int i=0;i<vt.size();i++) {
  	ans[vt[i]]='H';
  	ans[vt[i]+1]='O';
  }
  int last=0;
  for(int i=1;i<=n;i++)
    if (ans[i]) {
    	if (last) {
    		for(int j=last+1;j<i;j++) ans[j]=ans[last];
		}
		last=i;
	}
  if (last) {
  	for(int i=last+1;i<n;i++) ans[i]=ans[last];
  }
  if (!ans[1]) {
  	int r=1;
  	while (r<n-1&&!ans[r+1]) r++;
  	vt=ask(string(r,'O')+string(ans+r+1,ans+n));
  	if (vt.size()&&vt[0]==1) {
  		for(int i=1;i<=r;i++) ans[i]='O';
	  }
	else {
		for(int i=1;i<=r;i++) ans[i]='H';
	}
  }
  if (!ans[n]) {
  	vt=ask(string(ans+1,ans+n)+'C');
  	if (vt.size()) ans[n]='C';
  	else ans[n]=ans[n-1];
  }
}

void check() {
  int l=0,r=0;
  for(int i=1;i<=4;i++)
    if (ans[i]) {
    	if (!l) l=i;
    	r=i;
	}
  vector<int> vt;
  while (l>1) {
  	bool v=0;
  	vt=ask('C'+string(ans+l,ans+r+1));
    for(int i=0;i<vt.size();i++)
      if (vt[i]==l-1) {
      	ans[--l]='C';
      	v=1;
      	break;
	  }
	if (v) continue;
	vt=ask('O'+string(ans+l,ans+r+1));
    for(int i=0;i<vt.size();i++)
      if (vt[i]==l-1) {
      	ans[--l]='O';
      	v=1;
      	break;
	  }
	if (v) continue;
	ans[--l]='H';
  }
  while (r<4) {
  	bool v=0;
  	vt=ask(string(ans+l,ans+r+1)+'C');
    for(int i=0;i<vt.size();i++)
      if (vt[i]==l) {
      	ans[++r]='C';
      	v=1;
      	break;
	  }
	if (v) continue;
	vt=ask(string(ans+l,ans+r+1)+'O');
    for(int i=0;i<vt.size();i++)
      if (vt[i]==l) {
      	ans[++r]='O';
      	v=1;
      	break;
	  }
	if (v) continue;
	ans[++r]='H';
  }
}

void solve_4() {
  vector<int> vt;
  vt=ask("CO");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) {
  		ans[vt[i]]='C';
  		ans[vt[i]+1]='O';
	  }
  	check();
  	return;
  }
  vt=ask("CH");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) {
  		ans[vt[i]]='C';
  		ans[vt[i]+1]='H';
	  }
	check();
	return;
  }
  vt=ask("OH");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) {
  		ans[vt[i]]='O';
  		ans[vt[i]+1]='H';
	  }
  	check();
  	return;
  }
  vt=ask("HO");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) {
  		ans[vt[i]]='H';
  		ans[vt[i]+1]='O';
	  }
	check();
	return;
  }
  vt=ask("CCC");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) ans[vt[i]]=ans[vt[i]+1]=ans[vt[i]+2]='C';
  	check();
  	return;
  }
  vt=ask("OOO");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) ans[vt[i]]=ans[vt[i]+1]=ans[vt[i]+2]='O';
  	if (!ans[4]) ans[4]='C';
  	return;
  }
  vt=ask("HHH");
  if (vt.size()) {
  	for(int i=0;i<vt.size();i++) ans[vt[i]]=ans[vt[i]+1]=ans[vt[i]+2]='H';
  	if (!ans[4]) ans[4]='C';
  	return;
  }
  vt=ask("OOCC");
  if (vt.size()) {
  	ans[1]=ans[2]='O';
  	ans[3]=ans[4]='C';
  }
  else {
  	ans[1]=ans[2]='H';
  	ans[3]=ans[4]='C';
  }
}

int main() {
  int cases;
  cin>>cases;
  for(;cases;cases--) {
  	memset(ans,0,sizeof(ans));
  	int n;
  	cin>>n;
  	if (n==4) solve_4();
  	else solve_big(n);
  	cout<<"! "<<ans+1<<endl;
  	fflush(stdout);
  	int x;
  	cin>>x;
  }
  return 0;
}

F. Nora’s Toy Boxes

我们称一个盒子 $x$ 是关键的当且仅当 $\exist i\neq x,a_i\mid a_x$ ，那么只有所有关键的盒子可能被删去。且对于两个关键的盒子 $i$ 和 $j$ ，若存在非关键的盒子 $k$ ，使得 $a_k\mid a_i$ 且 $a_k \mid a_j$ ，我们在 $(i, j)$ 间连一条边，那么易知对于一个关键盒子 $x$ ，某个时刻它可被删去当且仅当有边 $(x, i)$ 使得盒子 $i$ 未被删去。
注意到对于得到的图的每个连通块 $S$ ，显然我们恰好最多能删去 $∣ S ∣ - 1$ 个盒子（这是上界，且任取一个不删去的点 $x$ 求DFS树，按DFS序倒序删除即可）。
合并不同连通块间对答案的贡献仅需乘上一个组合数，接下来只考虑单个连通块。考虑到确定了不被删去的点 $x$ ，那么相当于求剩下的点有多少标号顺序，使得不存在点 $y$ 的标号比所有相邻点的标号大（令 $x$ 的标号为 $n$ ）。
这可以考虑容斥，我们钦定若干个点的标号分别比它们周围的点的标号大（这些点不能与 $x$ 相邻且形成独立集）。直接算还是不好算，考虑给我们钦定的点之间的标号也确定顺序，从小往大枚举，那么这样的话令点 $i$ 与周围相邻点的集合为 $E (i)$ ，那么对于一个枚举的点序列 $(p_1,p_2,\cdots,p_k)$ ，贡献为 $(-1)^k\cdot \frac{(|S|-1)!}{\prod_{i=1}^{k}|E(p_1)\cup E(p_2)\cup \cdots \cup E(p_k)|}$ （ $p_i\notin E(p_1)\cup E(p_2)\cup \cdots \cup E(p_{i-1})$ ）。这样可以状压DP计算，令 $F [T]$ 表示当前的 $E(p_i)$ 的并为 $T$ 的贡献和，每次枚举一个不在 $T$ 中且不与 $x$ 相邻的点转移。容易发现这里对 $x$ 的枚举是不必要的，贡献到答案时只需找一个不在 $T$ 中的点作为 $x$ 即可（也即乘上 $∣ S ∣ - ∣ T ∣$ ）。
事实上这个DP的状态数不大，直接用map记忆化即可通过。对于一个非关键盒子 $x$ ，令 $P(x)=\{ i\mid a_x\mid a_i,i\neq x\}$ ，那么任意时刻的 $T$ 都是若干个 $S$ 对应的 $x$ 的 $P (x)$ 的并集。因此单个连通块状态数上限为 $2^r$ ，其中 $r$ 是单个连通块最多对应的非关键盒子个数。令权值上限为 $w$ ，注意到 $a_x \geq \lfloor \frac{w}{2} \rfloor$ 的 $x$ 显然没有用，且非关键盒子的 $a$ 之间构成了整除关系下的反链，而容易证明 $1\sim k$ 的最长反链不超过 $\lceil \frac{k}{2} \rceil$ （根据dilworth定理，最长反链不超过最小链覆盖，显然所有 $1\sim k$ 间的奇数集合即为一组链覆盖），那么就有 $r\leq \frac{w}{4}$ 。
时间复杂度为 $\mathcal O(2^{\frac{w}{4}}\cdot n^2)$ 。

#include <bits/stdc++.h>
#define MOD 1000000007
#define FR first
#define SE second
 
using namespace std;
 
typedef long long ll;

ll C[65][65],facd[65],inv[65];

void pre(int n) {
  for(int i=0;i<=n;i++) C[i][0]=1;
  for(int i=1;i<=n;i++)
    for(int j=1;j<=i;j++) C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
  facd[0]=1;
  for(int i=1;i<=n;i++) facd[i]=facd[i-1]*i%MOD;
  inv[1]=1;
  for(int i=2;i<=n;i++) inv[i]=(MOD-MOD/i)*inv[MOD%i]%MOD;
}
 
ll num[65];
map <ll,int> f[65];

inline ll getbit(ll n) {
  return __builtin_popcount(n>>32)+__builtin_popcount(n&((1LL<<32)-1));
}

ll dp(int n) {
  for(int i=0;i<=n;i++) f[i].clear();
  ll ans=0;
  f[0][0]=1;
  for(int i=0;i<n;i++)
    for(map<ll,int>::iterator it=f[i].begin();it!=f[i].end();it++) {
    	ll x=it->FR,v=it->SE;
    	ans=(ans+v*(n-i))%MOD;
    	for(int j=1;j<=n;j++)
    	  if (!((x>>(j-1))&1)) {
    	  	ll u=(x|num[j]);
    	  	int t=getbit(u);
    	  	f[t][u]=(f[t][u]-v*inv[t]%MOD+MOD)%MOD;
		  }
	}
  ans=ans*facd[n-1]%MOD;
  return ans;
}

bool e[65][65];
int id[65],dfs_cnt;
bool vis[65];

int dfs(int x,int n) {
  vis[x]=1;
  id[++dfs_cnt]=x;
  int s=1;
  for(int i=1;i<=n;i++)
    if (e[x][i]&&!vis[i]) s+=dfs(i,n);
  return s;
}

int a[65];
bool ban[65];
 
int main() {
  int n;
  scanf("%d",&n);
  pre(n);
  for(int i=1;i<=n;i++) scanf("%d",&a[i]);
  sort(a+1,a+n+1);
  for(int i=1;i<=n;i++)
    if (!ban[i]) {
    	for(int j=i+1;j<=n;j++)
    	  if (a[j]%a[i]==0) {
    	  	ban[j]=1;
    	  	for(int k=j+1;k<=n;k++)
    	  	  if (a[k]%a[i]==0) e[j][k]=e[k][j]=1;
		  }
	}
  int s=0;
  ll ans=1;
  for(int i=1;i<=n;i++)
    if (ban[i]&&!vis[i]) {
    	dfs_cnt=0;
    	int sz=dfs(i,n);
    	for(int j=1;j<=sz;j++) {
    		num[j]=(1LL<<(j-1));
    		for(int k=1;k<=sz;k++)
    		  if (e[id[j]][id[k]]) num[j]^=(1LL<<(k-1));
		}
		s+=sz-1;
		ans=ans*dp(sz)%MOD*C[s][sz-1]%MOD;
	}
  printf("%lld\n",ans);
  return 0;
}