洛谷4895 独钓寒江雪 （树哈希+dp+组合）
qwq
首先，如果是没有要求本质不同的话，那么还是比较简单的一个树形dp
我们令\(dp[i][0/1]\)表示是否\(i\)的子树，是否选\(i\)这个点的方案数。
一个比较显然的想法。
\(dp[i][0]=\prod (dp[p][0]+dp[p][1])\)
\(dp[i][1]=\prod dp[p][0]\)
最后直接将一号点的答案加起来就好。
qwq但是如果写一发，就会发现第二个样例就wei掉了
（因为题目要求本质不同）
qwq
那么这个东西应该怎么做呢。
因为本质不同，所以对于\(x\)形态和\(y\)形态，在同一个根的两个形态一样的子树中，顺序并不影响贡献的。
所以考虑如果存在相同的应该怎么计算答案。
为了避免出现子树和整棵树除去这个子树之后的形态相似。
我们选择用重心来当做整个树的根。
因为重心的每个儿子都小于\(\frac{size}{2}\)
（如果存在两个重心的话，一个比较简便的计算方法就是用一个新点，连接两个点）
那么由于题目中的本质不同是旋转同构，所以如果两个子树形态相同，但是处于不同的子树，不需要一起计算（因为没法保证其他部分还相同）
所以我们就要求的是，对于每一个子树，求他本质相同的子树的贡献。
那么同一个形态的子树应该怎么统计答案呢。
int p = (dp[v[i-1]][0]+dp[v[i-1]][1])%mod;
int pp = dp[v[i-1]][0]%mod;
p%=mod;
pp%=mod;
//dp[x][0]=(dp[x][0]*C(p+now-1,p-1))%mod;
//dp[x][1]=(dp[x][1]*C(pp+now-1,pp-1))%mod;
dp[x][0]=(dp[x][0]*C(p+now-1,now))%mod;
dp[x][1]=(dp[x][1]*C(pp+now-1,now))%mod;//隔板，允许为空
//由于要求本质不同，所以我们相当于对于这now个同形态子树，放到对应的方案数的箱子里，允许为空，所以是隔板法、
//因为AAB和BAA是本质相同的。
now=1;
因为AAB和BAA是本质相同的。
所以其实我们将相当于把一些方案数，放到不同的子树内部。因为影响的答案只会是每个形态的个数。
这个是一个组合数，如果方案数是\(p\)，然后同形态的子树个数是\(now\)，
\[C^{now}_{p+now-1}
\]
实际上这个是隔板（允许为空），一个经典套路
但是为了计算方便，我们选择选与他对称的一个组合数进行计算，因为\(now\)的范围是\(O(n)\)的，我们可以直接用循环求组合数（其实也没别的办法啊）
那么现在就剩下一个问题了，就是如何判断形态相同。
这时候就需要树哈希了
sro DT_Kang orz
这里用的是亢爷的一种树哈希的做法。
void dfs1(int x,int fa)
{
int num=0;
vector<int> v;
v.clear();
ha[x]=1;
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
dfs1(p,x);
}
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
v.pb(p);
num++;
}
sort(v.begin(),v.end(),cmp);
for (int i=0;i<num;i++)
{
ha[x]=(ha[x]+ha[v[i]]*mi[i+1])%mod;
}
ha[x]=ha[x]*size[x]%mod;
}
首先，我们对于每个子树，统计他的每个儿子，按照哈希值进行排序，从小到大乘上\(mi\)，然后最后用整个的哈希值，乘上子树大小
（可以直接当成一个套路去记）
下面弄上整个代码。
// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#define int long long
#define pb push_back
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
return x*f;
}
const int maxn = 1e6+1e2;
const int maxm = 2*maxn;
const int mod = 1e9+7;
const int qwq = 2333;
int point[maxn],nxt[maxm],to[maxm];
int cnt=1,n,m;
int ha[maxn];
int size[maxn],root,root1,root2;
int dp[maxn][2];
int mx[maxn];
int mi[maxn];
int power[maxn],inv[maxn];
int maxson,ymh=1e9;
void addedge(int x,int y)
{
nxt[++cnt]=point[x];
to[cnt]=y;
point[x]=cnt;
}
int qsm(int i,int j)
{
int ans=1;
while (j)
{
if (j&1) ans=ans*i%mod;
j>>=1;
i=i*i%mod;
}
return ans;
}
int C(int n,int m)
{
n=n%mod;
m=(m+mod)%mod;
int ans=1;
for (int i=n-m+1;i<=n;i++) ans=ans*i%mod;
//if (inv[m]==0) cout<<m<<"()()("<<endl;
ans=ans*inv[m]%mod;
//int ss=ans+1;
return ans;
}
void init(int n)
{
n+=10;
power[0]=1;
inv[0]=1;
for (int i=1;i<=n;i++) power[i]=power[i-1]*i%mod;
inv[n]=qsm(power[n],mod-2);
for (int i=n-1;i>=1;i--) inv[i]=inv[i+1]*(i+1)%mod;
mi[0]=1;
for (int i=1;i<=n;i++) mi[i]=mi[i-1]*qwq%mod;
}
void getroot(int x,int fa)
{
size[x]=1;
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
getroot(p,x);
size[x]+=size[p];
mx[x]=max(mx[x],size[p]);
}
mx[x]=max(mx[x],n-size[x]);
if (mx[x]<ymh)
{
ymh=mx[x];
root1=x;
}
else if (mx[x]==ymh) root2=root1,root1=x;
}
void dfs(int x,int fa)
{
size[x]=1;
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
dfs(p,x);
size[x]+=size[p];
}
}
int a[maxn];
bool cmp(int a,int b) //sro DT_Kang orz
{
return ha[a]<ha[b];
}
void dfs1(int x,int fa)
{
int num=0;
vector<int> v;
v.clear();
ha[x]=1;
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
dfs1(p,x);
}
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
v.pb(p);
num++;
}
sort(v.begin(),v.end(),cmp);
for (int i=0;i<num;i++)
{
ha[x]=(ha[x]+ha[v[i]]*mi[i+1])%mod;
}
ha[x]=ha[x]*size[x]%mod;
}
void solve(int x,int fa)
{
dp[x][0]=dp[x][1]=1;
int num=0;
vector<int> v;
v.clear();
for (int i=point[x];i;i=nxt[i])
{
int p = to[i];
if (p==fa) continue;
solve(p,x);
v.pb(p);
num++;
}
sort(v.begin(),v.end(),cmp);
int now = 1;
v.pb(n+2);
for (int i=1;i<=num;i++)
{
//cout<<v[i]<<"***"<<" ";
if (ha[v[i]]!=ha[v[i-1]])
{
int p = (dp[v[i-1]][0]+dp[v[i-1]][1])%mod;
int pp = dp[v[i-1]][0]%mod;
p%=mod;
pp%=mod;
//dp[x][0]=(dp[x][0]*C(p+now-1,p-1))%mod;
//dp[x][1]=(dp[x][1]*C(pp+now-1,pp-1))%mod;
dp[x][0]=(dp[x][0]*C(p+now-1,now))%mod;
dp[x][1]=(dp[x][1]*C(pp+now-1,now))%mod;//隔板，允许为空
//由于要求本质不同，所以我们相当于对于这now个同形态子树，放到对应的方案数的箱子里，允许为空，所以是隔板法、
//因为AAB和BAA是本质相同的。
now=1;
}
else
now++;
//cout<<v[i]<<endl;
}
//if (dp[x][0]==0) cout<<x<<" "<<dp[x][0]<<endl;
}
signed main()
{
n=read();ha[n+2]=mod+2;
init(n);
for (int i=1;i<n;i++)
{
int x=read(),y=read();
addedge(x,y);
addedge(y,x);
}
getroot(1,0); //求重心
if (mx[root2]==ymh)
{
root=n+1;
for (int i=point[root1];i;i=nxt[i])
{
int p = to[i];
if (p==root2)
{
to[i]=to[i^1]=n+1;
break;
}
}
addedge(root,root1);
addedge(root,root2);
}
else
{
root = root1;
}
// cout<<root<<endl;
memset(size,0,sizeof(size));
dfs(root,0);
dfs1(root,0);
// cout<<1<<endl;
solve(root,0);
//cout<<root<<endl;
//cout<<root1<<" "<<root2<<endl;
//cout<<1<<endl;
if (root==root1)
{
//cout<<"****"<<endl;
cout<<(dp[root][0]+dp[root][1])%mod;
return 0;
}
int ans=0;
if (ha[root1]==ha[root2])
{
int p = dp[root2][0]%mod;
ans=(dp[root1][1]*dp[root2][0]%mod+C(p+2-1,2))%mod;
}
else
{
//cout<<"*****************"<<endl;
ans=(dp[root1][1]*dp[root2][0]%mod+dp[root1][0]*dp[root2][1]%mod+dp[root1][0]*dp[root2][0]%mod)%mod;
}
cout<<ans;
return 0;
}
