【学习笔记】AGC009/AGC019/AGC029/AGC035

AGC009

Eternal Average

奥妙重重

如果我们用树的结构来描述操作，设一个点的深度为$x_i$，那么一定满足$\sum k^{-x_i}=1$，并且 $Z={\sum }_{a_i=1}{k}^{-x_i}$。

方便起见，我们引入$k$进制小数的概念。设$Z=0.z_1{z}_2...z_n$，其中$z_i$表示$k^{-i}$，$z_n\ne 0$ 。

那么合法的小数部分 { z i } \{z_i\} {zi​}应该满足：

$1.1$ 如果不进位，那么${\sum }_{i=1}^n{z}_i=n$
$1.2$ 如果进位，那么${\sum }_{i=1}^n{z}_i\le n$ ，并且每次进位会导致数位之和减去$k-1$，${\sum }_{i=1}^n{z}_i\equiv n(\mathrm{mod}k-1)$ 。

假设上述限制是充要的。换句话说，我们只关注$Z$最终的形式，而不关注具体的方案。

不妨做一些逆向思考。知道了$Z$的最终形式后，通过不断拆分高位可以得到恰好$n$个数，而根据这$n$个点的深度又可以把实际的操作树求出来。具体操作是，从根节点开始分裂，在每一层保留恰当的点数，不难自行验证。扯得有点远了

最后不要忘了$\sum k^{-x_i}=1$这个条件，事实上这等价于${\sum }_{a_i=0}{k}^{-x_i}=1-Z=0.(k-1-z_1)(k-1-z_2)...(k-z_n)$ ，根据上述推导得出$1+{\sum }_{i=1}^n(k-1-z_i)\le m$并且$1+{\sum }_{i=1}^n(k-1-z_i)\equiv m(\mathrm{mod}k-1)$ 。

让我们总结一下。设$d{p}_{i,j}$表示当前从高到低考虑到第$i$位，数位之和为$j$的方案数。转移方程为$d{p}_{i,j}=\sum d{p}_{i-1,j-k}$ ，可以前缀和优化。因为$z_n\ne 0$所以可能要用$0/1$记录一下当前这位的状态。

复杂度$O(n^2)$。

#include
#define ll long long
#define pb push_back
#define fi first
#define se second
#define db double
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
const int mod=1e9+7;
int n,m,K;
ll dp[2005][2005][2],sum[2005][2005],res;
void add(ll &x,ll y){x=(x+y)%mod;}
int main(){
	cin>>n>>m>>K;
	dp[0][0][0]=1;for(int i=0;i<=n;i++)sum[0][i]=1;
	for(int i=1;i<=(n+m-1)/(K-1);i++){
		for(int j=0;j<=n;j++){
			add(dp[i][j][0],dp[i-1][j][0]+dp[i-1][j][1]);
			if(min(K-1,j)==j)add(dp[i][j][1],sum[i-1][j-1]);
			else add(dp[i][j][1],sum[i-1][j-1]-sum[i-1][j-min(K-1,j)-1]);
			if(j%(K-1)==n%(K-1)&&i*(K-1)-j+1<=m&&(i*(K-1)-j+1)%(K-1)==m%(K-1))add(res,dp[i][j][1]);
		}sum[i][0]=1;for(int j=1;j<=n;j++)sum[i][j]=(sum[i][j-1]+dp[i][j][0]+dp[i][j][1])%mod;
	}cout<<(res+mod)%mod;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

AGC019

Yes or No

组合数学题。

因为本人数学比较菜所以只会组合意义啦。

方便起见，我们引入坐标$(x,y)$表示当前状态。那么对于一条路径，猜对的问题数目就是蓝边的数量。

如果这条路径多次穿过$y=x$，那么我们只保留第一个交点，并对路径作对称，这样蓝边的数目并不会改变。

设交点坐标是$(x,x)$，发现蓝边的数目$(n-x)+x=n$是定值！最后我们认为对角线的贡献是路径与对角线的交点数目/2 。

答案是$n+\frac{{\sum }_{i=1}^m\left(\genfrac{}{}{0ex}{}{2i}{i}\right)\left(\genfrac{}{}{0ex}{}{n+m-2i}{n-i}\right)}{2\left(\genfrac{}{}{0ex}{}{n+m}{n}\right)}$。

复杂度$O(n)$。

$\text{remark}$ 妙处在于发现潜在的组合意义。

#include
#define ll long long
#define pb push_back
#define fi first
#define se second
#define db double
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
const int mod=998244353;
int n,m;
ll fac[1000005],inv[1000005],res;
ll fpow(ll x,ll y){
	ll z(1);
	for(;y;y>>=1){
		if(y&1)z=z*x%mod;
		x=x*x%mod;
	}return z;
}
void init(int n){
	fac[0]=1;for(int i=1;i<=n;i++)fac[i]=fac[i-1]*i%mod;
	inv[n]=fpow(fac[n],mod-2);for(int i=n;i>=1;i--)inv[i-1]=inv[i]*i%mod;
}
ll binom(int x,int y){
	return fac[x]*inv[y]%mod*inv[x-y]%mod;
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>m;if(n<m)swap(n,m);init(2*n);
	for(int i=1;i<=m;i++)res=(res+binom(2*i,i)*binom(n+m-2*i,n-i)%mod)%mod;
	cout<<(res*fpow(binom(n+m,n),mod-2)%mod*fpow(2,mod-2)%mod+n)%mod;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

AGC029

Wandering TKHS

考虑$u$到根节点的路径为 { t 1 , t 2 , . . . , t k } \{t_1,t_2,...,t_k\} {t1​,t2​,...,tk​}，当从$t_i$走到$t_{i+1}$时，会扩展子树内比$t_{i+1}$小的节点。因此想到设$d{p}_i$表示从$i$走到$f{a}_i$时，子树内扩展了多少个点。

记$F(u,v)$表示从$u$到$v$的路径上不包括$v$的最大的点，那么$v\in subtree(u)$有贡献等价于$F(v,u)<F(1,u)$ 。注意到$F(1,u)$是定值，因此只需维护$F(v,u)$。

考虑自底向上维护，假设$x\in son(u)$，对于小于$x$的路径直接设为$x$，用$(val,c)$记录权值为$val$的路径有$c$条，可以手写平衡树，复杂度$O(n{\log }^{2}n)$ 。当然，线段树合并是更优秀的写法，复杂度$O(n\log n)$。

#include
#define ll long long
#define pb push_back
#define fi first
#define se second
#define db double
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
int n,vis[200005],dep[200005],res[200005],dis[200005],rt[200005],dp[200005],f[200005],tot;
struct node{
	int l,r,sum;
}t[20000005];
vector<int>g[200005];
int ask(int p,int l,int r,int ql,int qr){
	if(!p)return 0;
	if(ql<=l&&r<=qr)return t[p].sum;
	int mid=l+r>>1;
	if(qr<=mid)return ask(t[p].l,l,mid,ql,qr);
	if(mid<ql)return ask(t[p].r,mid+1,r,ql,qr);
	return ask(t[p].l,l,mid,ql,qr)+ask(t[p].r,mid+1,r,ql,qr);
}
void ins(int &p,int l,int r,int x,int y){
	if(!p)p=++tot;t[p].sum+=y;
	if(l==r)return;
	int mid=l+r>>1;
	x<=mid?ins(t[p].l,l,mid,x,y):ins(t[p].r,mid+1,r,x,y);
}
void del(int &p,int l,int r,int ql,int qr){
	if(!p)return;
	if(ql<=l&&r<=qr){p=0;return;}
	int mid=l+r>>1;
	if(ql<=mid)del(t[p].l,l,mid,ql,qr);if(mid<qr)del(t[p].r,mid+1,r,ql,qr);
	t[p].sum=t[t[p].l].sum+t[t[p].r].sum;
}
int merge(int p,int q){
	if(!p||!q)return p+q;
	t[p].sum+=t[q].sum;
	t[p].l=merge(t[p].l,t[q].l),t[p].r=merge(t[p].r,t[q].r);
	return p; 
}
void dfs(int u,int topf){
	for(auto v:g[u]){
		if(v!=topf){
			dis[v]=max(dis[u],u),dep[v]=dep[u]+1,dfs(v,u);
			int tot=ask(rt[v],1,n,1,v-1);del(rt[v],1,n,1,v-1),ins(rt[v],1,n,v,tot+1);
			dp[u]+=(f[v]=ask(rt[v],1,n,1,dis[u]-1)),rt[u]=merge(rt[u],rt[v]);
		}
	}
}
void dfs2(int u,int topf,int sum){
	res[u]=sum+dp[u];
	for(auto v:g[u]){
		if(v!=topf)dfs2(v,u,sum+dp[u]-f[v]);
	}
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n;for(int i=1;i<n;i++){
		int u,v;cin>>u>>v,g[u].pb(v),g[v].pb(u);
	}for(auto u:g[1])dfs(u,1);for(auto u:g[1])dfs2(u,1,0);
	for(int i=2;i<=n;i++)cout<<res[i]+dep[i]+1<<' ';
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

Construction of a tree

神仙构造题。

我们首先构造二分图，左边是$n$个节点，右边是$n-1$个集合，$(u,E_i)$有边当且仅当$u\in E_i$。

然后有解的必要条件是，对于右边任意 S ⊆ { E 1 , E 2 , . . . , E n − 1 } S\subseteq\{E_1,E_2,...,E_{n-1}\} S⊆{E1​,E2​,...,En−1​}，设其对应的点集为$f(S)$，都有$|S|<f(S)$，否则一定会形成环。

事实上这是充要的。给出如下构造。

首先求一个大小为$n-1$的匹配。钦定左边没有被匹配的$v$为根节点，从$v$开始跑$DFS$树（首先把之前的匹配加进$DFS$树中），对于右边集合相连的两个点就在原树上连一条边。如果过程中途停止的话，当且仅当，对于所有左侧经过的点，与它们相邻的右边的点都经历过了，并且没有扩展出新点。

因为此时左边点多一个$v$，所以左边点数比右边点数多$1$，那么取右边边未经过的点， 它们在左侧对应的点也是未被经过的，那么$f(S)=|S|$，矛盾。

比较复杂。感性理解一下就好。

复杂度$O(n\sqrt{n})$ 。瓶颈在于$\text{dinic}$求最大匹配。

#include
#define ll long long
#define pb push_back
#define fi first
#define se second
#define db double
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
const int N=2e6+5;
int n,m,vis[N],head[N],nxt[N],to[N],cur[N],lab[N],cap[N],tot=1,v;
int U[200005],V[200005];
queue<int>Q;
void add(int u,int v,int w){
	to[++tot]=v,cap[tot]=w,nxt[tot]=head[u],head[u]=tot;
	to[++tot]=u,cap[tot]=0,nxt[tot]=head[v],head[v]=tot;
}
bool BFS(){
	for(int i=0;i<2*n;i++)lab[i]=-1;
	Q.push(2*n);
	while(Q.size()){
		int u=Q.front();Q.pop();
		for(int k=head[u];k;k=nxt[k]){
			int v=to[k];
			if(lab[v]==-1&&cap[k^1]>0)lab[v]=lab[u]+1,Q.push(v);
		}
	}return lab[0]!=-1;
}
int flow(int u,int lim){
	if(u==2*n)return lim;
	int used=0;
	for(int k=cur[u];k;k=nxt[k]){
		cur[u]=nxt[k];
		int v=to[k];
		if(lab[u]==lab[v]+1&&cap[k]){
			int tmp=min(lim-used,cap[k]);
			int ret=flow(v,tmp);
			cap[k]-=ret,cap[k^1]+=ret,used+=ret;
			if(used==lim)break;
		}
	}
	return used;
}
int dinic(){
	int tot=0;
	while(BFS()){
		for(int i=0;i<=2*n;i++)cur[i]=head[i];
		tot+=flow(0,0x3f3f3f3f);
	}
	return tot;
}
void dfs(int u){
	for(int k=head[u];k;k=nxt[k]){
		if(to[k]==0||vis[to[k]-n])continue;
		int id=to[k]-n;
		vis[id]=1;
		for(int l=head[to[k]];l;l=nxt[l]){
			if(cap[l])m++,U[id]=u,V[id]=to[l],dfs(to[l]);
		}
	}
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)add(0,i,1);for(int i=n+1;i<2*n;i++)add(i,2*n,1);
	for(int i=1;i<n;i++){
		int k;cin>>k;
		while(k--){
			int x;cin>>x,add(x,n+i,1);
		}
	}
	if(dinic()!=n-1)cout<<"-1";
	else{
		for(int k=head[0];k;k=nxt[k]){
			if(cap[k])v=to[k];
		}
		dfs(v);
		if(m!=n-1)cout<<"-1";
		else for(int i=1;i<n;i++)cout<<U[i]<<' '<<V[i]<<"\n";
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

AGC035

Add and Remove