[BZOJ:3162]:独钓寒江雪

题解：

求本质不同的独立集的个数

首先独立集的个数是很好做的

\(f[u][0/1]\)表示节点\(u\)不选/选的方案数

然后dp就是

\(f[u][0] = f[u][0] * (f[v][0] + f[v][1])\)

\(f[u][1] = f[u][1] * f[v][0]\)

考虑怎么去重

不论把这个树怎么转或者以哪一个点为根

最后重心肯定不会变

所以我们可以把重心拎出来当根

一般在树上求本质不同的东西可以优先考虑重心

然后如果有两个重心(最多肯定只有两个==)那么这两个重心肯定由一条边连着

就可以新建一个节点连向这两个重心

然后dp

在dp计数的时候

如果\(k\)个子树\(v\)是本质上相同的

那么这\(k\)个子树的贡献总和就是就是\(C(f[v][0] + (f[v][1]) + k - 1 , k)\)

要求的是本质不同的独立集

所以就相当于可以随意编号

那么我们假设有n个子树,每个子树都有m个方案

那么我们按照选择的方案排序后如果相同就是重复的

所以我们就让后面的每一个选择的方案编号都比前一个大

这样就相当于方程整数解问题了

还有一个问题就是这个组合数怎么算?

因为k不大但是前面那个东西太大了

所以我们就相当于把\(C(n,m)\)底下那个\((n-m)!\)和上面的约分

那么就变成了\(\frac{n * (n - 1) * .. * (n - m + 1)}{m!}\)

然后注意这题卡哈希卡的挺厉害

最后换成我的生日才过的

代码

#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
# define LL long long
# define ull unsigned long long
const int M = 500005 ;
const long long mod = 1e9 + 7 ;
const long long INF = 1e9 ;
const ull Base = 23333333333ULL ;
using namespace std ;
inline int read() {
    char c = getchar() ; int x = 0 , w = 1 ;
    while(c>'9'||c<'0') { if(c=='-') w = -1 ; c = getchar() ;  }
    while(c >='0' && c<='9') { x = x*10+c-'0' ; c = getchar() ; }
    return x*w ;
}

int n , num = 1 , hea[M] ;
int size[M] , sonsz[M] , tmx = INF , rtnum , rt[M] , st[M] ;
long long fac[M] , finv[M] ;
LL f[M][2] ;
ull hsh[M] ;
struct E { int nxt , to ; } edge[M << 1] ;

inline void add_edge(int from , int to) {
    edge[++num].nxt = hea[from] ;
    edge[num].to = to ; hea[from] = num ;
}
inline bool Cmp(int a , int b) {
    if(hsh[a] == hsh[b]) return ((f[a][0] + f[a][1]) % mod < (f[b][0] + f[b][1]) % mod) ;
    return hsh[a] < hsh[b] ;
}
inline bool Same(int a , int b) {
    if(hsh[a] == hsh[b] && ((f[a][0] + f[a][1]) % mod) == ((f[b][0] + f[b][1]) % mod)) return true ;
    return false ;
}
inline long long Fpw(long long Base , int k) {
    long long temp = 1 ;
    while(k) {
        if(k & 1) temp = (temp * Base) % mod ;
        Base = (Base * Base) % mod ; k >>= 1 ;
    }
    return temp ;
}
void Grt(int u , int father) {
    size[u] = 1 ; int Mx = -1 ;
    for(int i = hea[u] ; i ; i = edge[i].nxt) {
        int v = edge[i].to ; if(v == father) continue ;
        Grt(v , u) ; size[u] += size[v] ; Mx = max(Mx , size[v]) ;
    }
    Mx = max(Mx , n - size[u]) ; sonsz[u] = Mx ; tmx = min(tmx , Mx) ;
}
inline long long C(long long n , int m) {
    n %= mod ; if(n < m) return 0 ; long long Ans = 1 ; m = min(1LL * m , n - m) ;
    for(int i = n ; i >= n - m + 1 ; i --) Ans = (1LL * Ans * i) % mod ;
    Ans = (Ans * finv[m]) % mod ; return Ans ;
}
void Dfs(int u , int father) {
    f[u][0] = f[u][1] = 1 ;
    for(int i = hea[u] ; i ; i = edge[i].nxt) {
        int v = edge[i].to ; if(v == father) continue ;
        Dfs(v , u) ;
    }
    int top = 0 ;
    for(int i = hea[u] ; i ; i = edge[i].nxt) {
        int v = edge[i].to ; if(v == father) continue ;
        st[++top] = v ;
    }
    sort(st + 1 , st + top + 1 , Cmp) ;
    int l = 1 , r = 0 ;
    for(int v ; l <= top ; l = r + 1) {
        for(r = l ; r <= top ; r ++) {
            if(!Same(st[l] , st[r]))
                break ;
        }
        r -- ;
        v = st[l] ;
        f[u][1] = (f[u][1] * C(f[v][0] + r - l , r - l + 1)) % mod ;
        f[u][0] = (f[u][0] * C(f[v][0] + f[v][1] + r - l , r - l + 1)) % mod ;
    }
    ull tmp = 0 ;
    for(int i = 1 ; i <= top ; i ++)
        tmp = (tmp * Base + (hsh[st[i]] + i) * 20020911uLL) ;
    hsh[u] = tmp ;
}
int main() {
    n = read() ; fac[0] = 1 ; finv[0] = 1 ;
    for(int i = 1 ; i <= n ; i ++) {
        fac[i] = (fac[i - 1] * i) % mod ;
        finv[i] = Fpw(fac[i] , mod - 2) ;
    }
    for(int i = 1 , u , v; i < n ; i ++) {
        u = read() , v = read() ;
        add_edge(u , v) ; add_edge(v , u) ;
    }
    Grt(1 , 1) ;
    for(int i = 1 ; i <= n ; i ++)
        if(sonsz[i] == tmx)
            rt[++rtnum] = i ;

    int k = rt[1] ;
    for(int i = hea[rt[1]] ; i ; i = edge[i].nxt) {
        int v = edge[i].to ;
        if(v == rt[2]) {
            k = n + 1 ;
            edge[i].to = edge[i ^ 1].to = k ;
            break ;
        }
    }
    if(rtnum > 1) {
        add_edge(k , rt[1]) ;
        add_edge(k , rt[2]) ;
    }
    Dfs(k , k) ;
    if(rtnum == 1) printf("%lld\n",(f[rt[1]][0] + f[rt[1]][1] + mod) % mod) ;
    else if(rtnum == 2) {
        int x = rt[1] , y = rt[2] ;
        if(hsh[x] != hsh[y])
            printf("%lld\n",(f[x][0] * f[y][0] + f[x][0] * f[y][1] + f[x][1] * f[y][0]) % mod) ;
        else printf("%lld\n",(C(f[x][0] + 1 , 2) + f[x][0] * f[y][1]) % mod) ;
    }
    return 0 ;
}