【学习笔记】NOMURA Programming Competition 2020

C - Folia

不难想到自底向上确定树的形态。可能要多尝试一下

一开始想错了好几个地方，服了

假设某一层有$X$个节点，那么上一层可能有$\lceil \frac{X}{2}\rceil ,\lceil \frac{X}{2}\rceil +1,...,X$个节点（不包括叶子节点），那么我们可以很容易的递推求出每一层的$[l_i,r_i]$表示这一层点数的取值范围。但是并不是每一层的$r_i$都是能取到的，因为$r_i\le 2^i$，而且$2^i$比较大不太好处理。

基于上述两个理由，我们考虑自顶向下确定每一层点的取值，每一层贪心取最大点数即可。并且可以证明答案不会超过long long

#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
int n,a[100005];
ll l[100005],r[100005],res=1;
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n;for(int i=0;i<=n;i++)cin>>a[i];
	if(n&&a[0]){
		cout<<-1;
		return 0;
	}
	l[n]=r[n]=a[n];
	for(int i=n-1;i>=0;i--){
		l[i]=a[i]+(l[i+1]+1)/2;
		r[i]=a[i]+r[i+1];
	}
	if(l[0]>1){
		cout<<-1;
		return 0;
	} 
	ll X=1;
	for(int i=1;i<=n;i++){
		X=min(r[i],2*(X-a[i-1]));
		if(X<l[i]){
			cout<<-1;
			return 0;
		}
		res+=X;
	}cout<<res;
}

D - Urban Planning

对于给定的$\{p_i\}$，贡献就是$n$减去连通块的个数。

笑死，然而还是不会做

注意到$\{p_i\}$对应导出的图是一个基环树森林，因此环的数目等于连通块的数目，要算所有情况下环数目的和，可以对于每个环单独考虑它出现次数的方案数。该死，为什么我这一步都没转化出来就像计数了啊

然后先考虑$p_i=-1$的情形。不过这道题的突破口好像不在这里，因为随便用组合数算算没啥难度

还是要考虑题目给定的$\{p_i\}$长什么样子。奇怪啊，竟然要对这一点特别提出来考虑 我们发现，其给出的图一定是由若干内向基环树和内向树构成 刚开始把内向树想成链了，真是奇怪。假设有$M$个基环树，那么对答案造成的贡献是固定的$M(N-1{)}^K$；假设有$K^{\prime }$个内向树，那么只有根节点指向的边不是固定的，注意我们的目标还是数环。

为什么题解的式子这么简洁

定义环上的关键点为内向树的根节点以及$p_i=-1$的那些点。记这些点为$\{a_i\}$，子树大小为$\{b_i\}$，那么方案数为$(n-1)!(N-1{)}^{K-n}\prod b_i$，其中$n$表示环上的点数。不难证明这个计数方式不重不漏。

复杂度$O(n^2)$。代码非常简单，只需要一个简单的背包即可。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
int n,m,K,fa[5005],p[5005],sz[5005],vs[5005];
ll fac[5005],F[5005],dp[5005],res;
int find(int x){
	return fa[x]==x?x:fa[x]=find(fa[x]);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++)fa[i]=i,sz[i]=1;
	fac[0]=F[0]=1;for(int i=1;i<=n;i++)fac[i]=fac[i-1]*i%mod,F[i]=F[i-1]*(n-1)%mod;
	for(int i=1;i<=n;i++){
		cin>>p[i];
		K+=(p[i]==-1);
		if(~p[i]){
			int u=find(i),v=find(p[i]);
			if(u!=v){
				fa[u]=v,sz[v]+=sz[u];
			}
			else{
				vs[u]=1,m++;
			}
		}
	}dp[0]=1;
	for(int i=1;i<=n;i++){
		if(fa[i]==i){
			if(!vs[i]){
				res=(res+(sz[i]-1)*F[K-1])%mod;
				for(int j=n;j>=1;j--){
					dp[j]=(dp[j]+dp[j-1]*sz[i])%mod;
				}
			}
			else{
				res=(res+F[K])%mod;
			}
		}
	}
	for(int i=2;i<=K;i++){
		if(dp[i]){
			res=(res+fac[i-1]*dp[i]%mod*F[K-i])%mod;
		}
	}cout<<(F[K]*n-res+mod)%mod;
}

E - Binary Programming

姑且先把这套题做着吧，其他的题也没精力翻了

考虑倒着做，然后贪心 这个过程中可能会产生一堆假做法，但是不要慌张 。

我企图直接贪心，然而产生了错误，我是joker，这里数据删除了

从何贪起呢，我们观察到$1$一定是放在最后删的，事实上这也是一个非常显然的结论。另一个观察我没有注意到，那就是无论怎么操作，相邻两个$1$对答案的贡献都是一样的，因此我们考虑把相邻的$1$删去，这样就不存在相邻的$1$了 。

然后就非常好搞了。设某个$1$前面$0$的个数为$x$，后面$0$的个数为$y$，那么对于奇数位上的$1$，贡献最大是$\lfloor \frac{x}{2}\rfloor +1+y$，对于偶数位上的$1$，贡献最大是$\lfloor \frac{x-1}{2}\rfloor +1+y$，显然这是可以取到的。

复杂度$O(n)$。

做这种题比较爽的地方是只要有了正确的思路就很好搞，不然就会有很多种情况

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n;
ll res,zero,one,sum;
char s[200005];
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	for(int i=1;i<=n;i++)sum+=(s[i]=='0');
	for(int i=1;i<=n;i++){
		if(s[i]=='0'){
			zero++;
		}
		else{
			one++;
			if(i+1<=n&&s[i+1]=='1'){
				res+=sum+1;
				one++;
				i++;
			}
			else{
				if(one&1)res+=zero/2+1+sum-zero;
				else res+=(zero-1)/2+1+sum-zero;
			}
		}
	}
	for(int i=1;i<=one;i++){
		res+=i/2;
	}
	cout<<res;
}

F - Sorting Game

该死，看到后面把前面的操作忘了，直接把$\text{Snuke}$的操作搞忘了，怪不得做不出来，先数据删除一波

一看到这个邻值交换就感到非常亲切，序列$\{a_i\}$合法等价于对于任意$i<j$，从高往低位找到第一个$c_i=1,c_j=0$时，其后面数位上的数完全相同。

嗯，读错题过后少考虑了一些因素，反而有帮助？

但是这个限制显然不能拿来直接计数。因为是平时训练题所以也懒得打表

到这里能发散的点还是挺多的，直接猜结论可能不一定会导向正确的方向

这题好做的原因可能还是在于没有什么特殊的限制，因此大胆猜测最终$dp$式子并不复杂

观察这个限制有点像数位$dp$。那么最基础的想法就是从高到低位考虑，打个表观察一下，于是不难发现这个想法的动机 然而这不是我最初的思路。。。 ：对于$i<j$，$a_i$和$a_j$的最高位分别是$1$,$0$，那么其剩余的数位一定完全相同。首先我们要知道，对于不存在子串$10$的情况，其方案数等价于$d{p}_{n,m-1}$。其中$d{p}_{n,m}$表示$n$个数，$m$个数位的方案数。

另一方面，如果存在这样的$i,j$，我们猜测可以把$i,j$以及它之间的东西一起压缩掉变成同一个数，假设中间有$K$个位置最高位不确定那么剩下的方案数就是$d{p}_{n-K-1,m-1}$ 。中间$K$个数最高位可以任取，方案数$2^K$。于是留给了我们一个艰巨的任务：证明这样的方案数是等价的。

至于这么压缩为什么是等价的，可以先写代码验证一番 ，或者更严谨地，因为后面数位的数都是复制粘贴所以可以只保留$i,j$两个数，因为不存在$10$所以都只能比后$j-1$位，于是就是等价的。

综上所述，$d{p}_{n,m}=(n+1)\times d{p}_{n,m-1}+{\sum }_{k=0}^{n-2}d{p}_{n-k-1,m-1}\times 2^k\times (n-k-1)$。

利用换元把式子写成$d{p}_{n,m}=(n+1)\times d{p}_{n,m-1}+{\sum }_{k=1}^{n-1}d{p}_{k,m-1}\times 2^{n-1-k}\times k$ 就可以$O(1)$转移了。

复杂度$O(nm)$。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
int n,m;
ll dp[5005][5005],sum[5005][5005],F[5005],F2[5005];
int main(){
	cin>>m>>n;
	F[0]=1;for(int i=1;i<=n;i++)F[i]=F[i-1]*2%mod;
	F2[0]=1;for(int i=1;i<=n;i++)F2[i]=F2[i-1]*(mod+1)/2%mod;
	for(int j=1;j<=m;j++){
		dp[0][j]=1;
		for(int i=1;i<=n;i++){
			if(j>1){
				dp[i][j]=((i+1)*dp[i][j-1]+sum[i-1][j-1]*F[i-1])%mod;
			}
			else{
				dp[i][j]=F[i];
			}
			sum[i][j]=(sum[i-1][j]+dp[i][j]*F2[i]%mod*i)%mod;
		}
	}
	cout<<dp[n][m];
}