C - Folia
不难想到自底向上确定树的形态。
假设某一层有 X X X个节点,那么上一层可能有 ⌈ X 2 ⌉ , ⌈ X 2 ⌉ + 1 , . . . , X \lceil\frac{X}{2}\rceil,\lceil\frac{X}{2}\rceil+1,...,X ⌈2X⌉,⌈2X⌉+1,...,X个节点(不包括叶子节点),那么我们可以很容易的递推求出每一层的 [ l i , r i ] [l_i,r_i] [li,ri]表示这一层点数的取值范围。但是并不是每一层的 r i r_i ri都是能取到的,因为 r i ≤ 2 i r_i\le 2^i ri≤2i,而且 2 i 2^i 2i比较大不太好处理。
基于上述两个理由,我们考虑自顶向下确定每一层点的取值,每一层贪心取最大点数即可。并且可以证明答案不会超过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 } \{p_i\} {pi},贡献就是 n n n减去连通块的个数。
注意到 { p i } \{p_i\} {pi}对应导出的图是一个基环树森林,因此环的数目等于连通块的数目,要算所有情况下环数目的和,可以对于每个环单独考虑它出现次数的方案数。
我们发现,其给出的图一定是由若干内向基环树和内向树构成。假设有 M M M个基环树,那么对答案造成的贡献是固定的 M ( N − 1 ) K M(N-1)^K M(N−1)K;假设有 K ′ K' K′个内向树,那么只有根节点指向的边不是固定的,注意我们的目标还是数环。
定义环上的关键点为内向树的根节点以及 p i = − 1 p_i=-1 pi=−1的那些点。记这些点为 { a i } \{a_i\} {ai},子树大小为 { b i } \{b_i\} {bi},那么方案数为 ( n − 1 ) ! ( N − 1 ) K − n ∏ b i (n-1)!(N-1)^{K-n}\prod b_{i} (n−1)!(N−1)K−n∏bi,其中 n n n表示环上的点数。不难证明这个计数方式不重不漏。
复杂度 O ( n 2 ) O(n^2) O(n2)。代码非常简单,只需要一个简单的背包即可。
#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
考虑倒着做,然后贪心 。
观察到 1 1 1一定是放在最后删的,事实上这也是一个非常显然的结论。另一个观察我没有注意到,那就是无论怎么操作,相邻两个 1 1 1对答案的贡献都是一样的,因此我们考虑把相邻的 1 1 1删去,这样就不存在相邻的 1 1 1了 。
然后就非常好搞了。设某个 1 1 1前面 0 0 0的个数为 x x x,后面 0 0 0的个数为 y y y,那么对于奇数位上的 1 1 1,贡献最大是 ⌊ x 2 ⌋ + 1 + y \lfloor\frac{x}{2}\rfloor+1+y ⌊2x⌋+1+y,对于偶数位上的 1 1 1,贡献最大是 ⌊ x − 1 2 ⌋ + 1 + y \lfloor\frac{x-1}{2}\rfloor+1+y ⌊2x−1⌋+1+y,显然这是可以取到的。
复杂度 O ( n ) O(n) 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
一看到这个邻值交换就感到非常亲切,序列 { a i } \{a_i\} {ai}合法等价于对于任意 i < j i<j i<j,从高往低位找到第一个 c i = 1 , c j = 0 c_i=1,c_j=0 ci=1,cj=0时,其后面数位上的数完全相同。
但是这个限制显然不能拿来直接计数。
观察这个限制有点像数位 d p dp dp。那么最基础的想法就是从高到低位考虑,打个表观察一下,于是不难发现这个想法的动机 :对于 i < j i<j i<j, a i a_i ai和 a j a_j aj的最高位分别是 1 1 1, 0 0 0,那么其剩余的数位一定完全相同。首先我们要知道,对于不存在子串 10 10 10的情况,其方案数等价于 d p n , m − 1 dp_{n,m-1} dpn,m−1。其中 d p n , m dp_{n,m} dpn,m表示 n n n个数, m m m个数位的方案数。
另一方面,如果存在这样的 i , j i,j i,j,我们猜测可以把 i , j i,j i,j以及它之间的东西一起压缩掉变成同一个数,假设中间有 K K K个位置最高位不确定那么剩下的方案数就是 d p n − K − 1 , m − 1 dp_{n-K-1,m-1} dpn−K−1,m−1 。中间 K K K个数最高位可以任取,方案数 2 K 2^K 2K。
至于这么压缩为什么是等价的,因为后面数位的数都是复制粘贴所以可以只保留 i , j i,j i,j两个数,因为不存在 10 10 10所以都只能比后 j − 1 j-1 j−1位,于是就是等价的。
综上所述, d p n , m = ( n + 1 ) × d p n , m − 1 + ∑ k = 0 n − 2 d p n − k − 1 , m − 1 × 2 k × ( n − k − 1 ) dp_{n,m}=(n+1)\times dp_{n,m-1}+\sum_{k=0}^{n-2}dp_{n-k-1,m-1}\times 2^k\times (n-k-1) dpn,m=(n+1)×dpn,m−1+∑k=0n−2dpn−k−1,m−1×2k×(n−k−1)。
利用换元把式子写成 d p n , m = ( n + 1 ) × d p n , m − 1 + ∑ k = 1 n − 1 d p k , m − 1 × 2 n − 1 − k × k dp_{n,m}=(n+1)\times dp_{n,m-1}+\sum_{k=1}^{n-1}dp_{k,m-1}\times 2^{n-1-k}\times k dpn,m=(n+1)×dpn,m−1+∑k=1n−1dpk,m−1×2n−1−k×k 就可以 O ( 1 ) O(1) O(1)转移了。
复杂度 O ( n m ) O(nm) 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];
}