Codeforces Round #728 (Div. 1) B.Tree Array(期望/概率 dp)

题目

n(n<=200)个点的树，你等概率地随机选一个点作为起始点，

选择了起始点之后，

接下来的每一步，等概率地选择与当前连通块连通的一个点，

并将其拓展，加入到访问顺序的排列中，

重复这个过程，直至将n个点拓展完，

求所有可能的排列中，逆序对的期望数，答案对1e9+7取模

思路来源

官方题解

题解

首先，肯定是统计每一对数的贡献，

而且对于一对固定的数来说，根不同的情况下也不便转移，

所以枚举根rt，枚举产生贡献的数对(a,b)，统计(a,b)的贡献，

不妨a<b，(a,b)产生贡献一定是rt先到b后到a，

注意到rt在到lca(a,b)前是没有影响的，

这棵树除去a到b的这一条链以外别的点也是没有影响的，

所以可以看成是rt先到lca(a,b)后，

不妨计lca(a,b)距离a的距离为dis[a]，计lca(a,b)距离b的距离为dis[b]

则可以看成是有两个栈，一个有disa个球，另一个有disb个球，

你每次等概率地从其中一个栈中选出一个球弹出来，求disb所在栈先被弹空的概率

dp[i][j]表示第二个栈的j个球先弹空的概率，

显然等概率要么转移到dp[i-1][j]要么转移到dp[i][j-1]，这个二维dp搞一下就好了

最后对答案除以一个n，表示每个根都是1/n的概率等概率选取的

暴力枚举root、枚举点对a、b，在线lca是O(n^3logn)的，离线tarjan是O(n^3)的，

这里的实现方法，类似启发式合并，

在把v往u上挂的时候，统计v和之前的v之间的点对的贡献，

这样就保证lca一定是u，而且复杂度也是O(n^3)的了

代码

#include<bits/stdc++.h>
using namespace std;
#define pb push_back
const int N=205,mod=1e9+7,inv2=(mod+1)/2;
//dp[i][j]表示距离大的数还有i步 小的数还有j步时先走到大的数的概率
int n,u,v,dep[N],dp[N][N],ans;
vector<int>e[N],now[N];
int modpow(int x,int n,int mod){
	int res=1;
	for(;n;n>>=1,x=1ll*x*x%mod){
		if(n&1)res=1ll*res*x%mod; 
	}
	return res;
}
void dfs(int u,int fa,int anc){
	dep[u]=dep[fa]+1;
	now[u].pb(u);
	for(auto &v:e[u]){
		if(v==fa)continue;
		dfs(v,u,anc);
		for(auto &x:now[v]){
			for(auto &y:now[u]){
				int a=dep[x]-dep[u],b=dep[y]-dep[u];
				if(x>y){
					ans=(ans+dp[a][b])%mod;
				}
				else{
					ans=(ans+dp[b][a])%mod;
				}
			}
		}
		for(auto &x:now[v]){
			now[u].push_back(x);
		}
	}
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<n;++i){
		scanf("%d%d",&u,&v);
		e[u].pb(v);e[v].pb(u);
	}
	for(int i=1;i<=n;++i){
		dp[0][i]=1; 
	}
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			dp[i][j]=1ll*(dp[i-1][j]+dp[i][j-1])%mod*inv2%mod;
		}
	}
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			now[j].clear();
		}
		dfs(i,0,i);
	}
	ans=1ll*ans*modpow(n,mod-2,mod)%mod;
	printf("%d\n",ans);
	return 0;
}