Codeforces Round #747 (Div. 2)

A.构造

我们每次选择$l=-n+1,r=n$

这样$[-n+1,n-1]$的元素和为$0$

所有和为$n$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
	ios::sync_with_stdio(0);
	int T;cin>>T;
	while (T--)
	{
		ll n;cin>>n;
		cout<<-n+1<<" "<<n<<"\n";
	}
}

B.思维

每一个幂次只能取$1$各或者$0$个，且底数大于$2$

那么就很简单了$n^k>{\sum }_0^{k-1}{n}^i$

因此，将$k$转化为$2$进制，然后再加上每一位为$1$的幂次

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;

int main()
{
	ios::sync_with_stdio(0);
	int T;cin>>T;
	while (T--)
	{
		int n,k;cin>>n>>k;
		ll res = 1;
		ll ans = 0;
		for (int i=0;i<32;++i)
		{
			if (k&1)
			{
				ans = (ans+res)%mod;
			}res = res*n%mod;
			k>>=1;
		}
		cout<<ans<<endl;
	}
}

C.思维

如果我们选取$x=n$，那么对于$1$到$n-1$位置上的字符都可以变成$c$

考虑到$n\ge 3$如果我们选取$n-1$，那么$n$一定无法整除$n-1$，一定可以把第$n$位置的字符变成$c$

因此，最多只需要两次操作

我们只需判断是否两次一下就可以完成

$0$次直接判断是否全部都为$c$

$1$次的话，遍历$i:[1,n]$，遍历所有能整除$i$的位置，判断此位置是否是$c$

时间复杂度$O(nlogn)$

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5+100;
char s[maxn];
int main()
{
	ios::sync_with_stdio(0);
	int T;cin>>T;
	while (T--)
	{
		int n;char c;cin>>n>>c;
		for (int i=1;i<=n;++i)cin>>s[i];
		bool f = true;
		for (int i=1;i<=n;++i)if (s[i]!=c)
		{
			f=false;
			break;
		}
		if (f)
		{
			cout<<"0\n";
			continue;
		}
		
		for (int i=1;i<=n;++i)
		{
			bool flag = true;
			for (int j=i;j<=n;j+=i)if (s[j]!=c)
			{
				flag = false;
				break;
			}
			if (flag)
			{
				f = true;
				cout<<"1\n"<<i<<"\n";
				break;
			}
		}
		if (!f)cout<<"2\n"<<n-1<<" "<<n<<"\n";
	}
}

D.思维+$dfs$

记$imposter:0,crewmate:1$

那么，如果$a$指示$b$为撒谎者，则有一条边$(a,b)$，边权为$0$

因此，我们发现，如果$a\stackrel{c}{\to }b$

什么时候是合法的呢？

枚举了各种情况之后发现

当且仅当$a\oplus b\oplus c=1$的时候，且我们确定了对于一个连通分量，如果我们直到一个点的值

那么对应的我们可以求出所有点的值

因此，遍历每一个联通分块两次，分别选联通分块中任意一点假设其权值为$0$和为$1$

虽然题目中是有向边，但建边时可以算作无向边

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
const int maxn = 3e5+100;
vector<pii> G[maxn];
int n,m;
int dfn[maxn],id[maxn];
int tot,res;
void dfs(int u,int mark,int sta)
{
	id[u]=sta;dfn[u]=tot;
	if (sta==0)++res;
	for (pii p:G[u])
	{
		if (res==-1)return;
		int v = p.first;
		int c = p.second;
		if (dfn[v]!=tot)dfs(v,mark,c^sta^1);
		else if (id[v]!=c^sta^1)
		{
			res=-1;
			return;
		}
	}
}
int main()
{
	ios::sync_with_stdio(0);
	int T;cin>>T;
	while (T--)
	{
		cin>>n>>m;
		for (int i=1;i<=n;++i)
		{
			G[i].clear();
			dfn[i]=0;
		}tot=0;
		string s;
		for (int i=1,u,v;i<=m;++i)
		{
			cin>>u>>v>>s;
			int tmp = 1;
			if (s=="imposter")tmp=0;
			G[u].push_back(pii(v,tmp));
			G[v].push_back(pii(u,tmp));
		}
		int ans=0;
		for (int i=1;i<=n;++i)if (dfn[i]==0)
		{
			int ret = -1;
			res=0;
			dfs(i,++tot,0);
			ret = max(ret,res);
			res = 0;
			dfs(i,++tot,1);
			ret = max(ret,res);
			if (ret==-1)
			{
				ans = -1;
				break;
			}ans+=ret;
		}
		cout<<ans<<"\n";
	}
}

E1.$dp$

定义$dp$状态$dp[i]$表示一个深度为$i$的节点，在顶点颜色已经确定的情况下，其子树一共有多少染色方案

很显然$dp[k]=1$

考虑魔方涂色，一种颜色可以和四种别的颜色相邻

因此，父节点确定的情况下，子节点可以取$4$种颜色

因此KaTeX parse error: Undefined control sequence: \* at position 8: dp[i]=4\̲*̲dp[i+1]\*4\*dp[…

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
ll dp[65];
int main()
{
	ios::sync_with_stdio(0);
	int k;cin>>k;dp[k]=1;
	for (int i=k-1;i>=1;--i)dp[i]=dp[i+1]*dp[i+1]%mod*16%mod;
	cout<<6*dp[1]%mod<<endl;
}

E2.$dp$+思维

问题一下子变棘手了

有一些点的颜色已经被确定了！

回忆$E1$中我们的解题策略，我们实际上忽略了颜色的区别。

$d{p}_0[i]:$ 表示一个深度为$i$的节点，在顶点颜色已经确定的情况下，其子树一共有多少染色方案

事实上，我们忽略了颜色是什么

增加颜色变量$dp[i][j]:$ 表示一个深度为$i$的节点，在顶点颜色为$j$下，其子树一共有多少染色方案

仅仅是这样还是没有办法求的

再次扩大$dp$的范围空间

$dp[i][j]:$ 表示一个的节点$i$，颜色为$j$，其子树一共有多少染色方案

这就可以求解了

$dp[i][j]={\sum }_{k_1=0}^{5}dp[i<<1][k_1]\ast {\sum }_{k_2=0}^{5}dp[i<<1|1][k_2]$

其中$k_1,k_2$还必须满足与颜色$j$相邻

但是，考虑到$i\le 2^k-1,k\le 60$

很明显，时间空间都过大了，必须优化

观察到$n\le 2000$ 事先限制颜色的点的个数很小，这给了我们启发

对于一个节点$u$，其深度为$d$

如果其子树中没有事先就被限制了的点，那么$dp[u][0]=dp[u][1]=\cdots =dp[u][5]=d{p}_0[d]$

就和$E1$一样了，我们根本不用去遍历到这些节点，我们本来就可以通过他们的深度直接得到他们的值

那么，我们必须要遍历到的节点有哪些呢？

具体说，子树中包含着事先被限制颜色点的节点有哪些呢？

这些点的个数最多不会超过KaTeX parse error: Undefined control sequence: \* at position 2: n\̲*̲k\le 2000\*60 (所有的父节点)

因此，我们只需对这些节点进行$dp$状态的遍历转移即可

找到这些点，

1. 如果这些点事先就被限制了颜色，则其他颜色情况下都为零。否则枚举该点的颜色
2. 该点颜色确定，按照上面公式转移。如果子节点不是特殊的节点，利用$d{p}_0$得到答案

关于上面第二步，因为父节点的转移依靠子节点，所以我们在更新特殊节点时应当按照深度从深向浅更新

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
map<string,int> mp;
map<ll,int> mmp;
map<ll,ll> ans[7];
ll dp[65];
inline int geth(ll num)
{
	int ans = 0;
	while (num)
	{
		++ans;
		num>>=1L;
	}return ans;
}
vector<ll> vec;
int main()
{
	ios::sync_with_stdio(0);
	mp["white"]=0;mp["yellow"]=1;
	mp["green"]=2;mp["blue"]=3;
	mp["red"]=4;mp["orange"]=5;
	int k;cin>>k;dp[k]=1;
	for (int i=k-1;i>=1;--i)dp[i]=dp[i+1]*dp[i+1]%mod*16%mod;
	int n;cin>>n;
	for (int i=1;i<=n;++i)
	{
		ll id;string col;
		cin>>id>>col;
		mmp[id]=mp[col];
		while (id>0)
		{
			vec.push_back(id);
			id>>=1L;
		}
	}sort(vec.begin(),vec.end(),[](ll na,ll nb){
		return na>nb;
	});
	for (int i=0;i<vec.size();++i)if (i==0||vec[i]!=vec[i-1])
	{
		ll u = vec[i];
		int h = geth(u);
		for (int i=0;i<6;++i)
		{
			if (mmp.count(u)&&i!=mmp[u])
			{
				ans[i][u]=0;
				continue;
			}
			if (h==k)ans[i][u]=1;
			else
			{
				ll ls = u<<1L;
				ll rs = u<<1L|1L;
				ll lsum=0,rsum=0;
				for (int j=0;j<6;++j)if (j!=i&&j!=(i^1))
				{
					if (ans[j].count(ls))lsum = (lsum+ans[j][ls])%mod;
					else lsum = (lsum+dp[h+1])%mod;
					
					if (ans[j].count(rs))rsum = (rsum+ans[j][rs])%mod;
					else rsum = (rsum+dp[h+1])%mod;
				}
				ans[i][u] = lsum*rsum%mod;
			}
		}
	}
	ll res = 0;
	for (int i=0;i<6;++i)
	{
		if (ans[i].count(1))res = (res+ans[i][1])%mod;
		else res = (res+dp[1])%mod;
	}cout<<res<<endl;
}