【HDU】5789 Permutation【dp】

题目链接：Permutation

#include <bits/stdc++.h>
using namespace std ;

typedef long long LL ;
typedef vector < int > vi ;
typedef map < LL , int > mpvi ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 55 ;
const int MAXE = 200 ;
const int mod = 1e9 + 7 ;

struct Edge {
    int v , n ;
    Edge () {}
    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int dp[MAXN] , dp2[MAXN] , nxt[MAXN] , siz[MAXN] ;
int f[MAXN] , vf[MAXN] ;
int pre[MAXN] , dep[MAXN] ;
int n , root ;
int ans ;

void init () {
    cntE = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
    E[cntE] = Edge ( v , H[u] ) ;
    H[u] = cntE ++ ;
}

LL c ( int x , int y ) {
    if ( x < y ) return 0 ;
    return 1LL * f[x] * vf[y] % mod * vf[x - y] % mod ;
}

int powmod ( int x , int n ) {
    int res = 1 ;
    while ( n ) {
        if ( n & 1 ) res = 1LL * res * x % mod ;
        x = 1LL * x * x % mod ;
        n >>= 1 ;
    }
    return res ;
}

void dfs ( int u ) {
    siz[u] = 1 ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == pre[u] ) continue ;
        pre[v] = u ;
        dep[v] = dep[u] + 1 ;
        dfs ( v ) ;
        siz[u] += siz[v] ;
    }
    dp[u] = f[siz[u] - 1] ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == pre[u] ) continue ;
        dp[u] = 1LL * dp[u] * dp[v] % mod * vf[siz[v]] % mod ;
    }
}

int get_lca ( int x , int y ) {
    while ( x != y ) {
        if ( dep[x] < dep[y] ) swap ( x , y ) ;
        x = pre[x] ;
    }
    return x ;
}

int calc ( int x , int y ) {
    int flag = 0 ;
    if ( x == 6 && y == 3 ) flag = 1 ;
    int lca = get_lca ( x , y ) ;
    if ( lca == x ) return 0 ;
    if ( lca == y ) return dp[root] ;
    for ( int i = 0 ; i <= n ; ++ i ) {
        dp2[i] = 0 ;
    }
    for ( int i = 1 ; i <= siz[y] ; ++ i ) {
        dp2[i] = 1LL * c ( siz[x] - 1 + siz[y] - i , siz[x] - 1 ) * dp[x] % mod * dp[y] % mod ;
    }
    int tot = siz[x] + siz[y] , must = siz[x] ;
    while ( pre[y] != lca ) {
        int z = y ;
        y = pre[y] ;
        for ( int o = H[y] ; ~o ; o = E[o].n ) {
            int u = E[o].v ;
            if ( u == pre[y] || u == z ) continue ;
            for ( int i = 0 ; i <= tot + siz[u] ; ++ i ) {
                nxt[i] = 0 ;
            }
            for ( int i = tot - must ; i >= 1 ; -- i ) {
                for ( int j = siz[u] ; j >= 0 ; -- j ) {
                    int v = tot - i - 1 + siz[u] - j ;
                    nxt[i + j] = ( nxt[i + j] + 1LL * dp2[i] * c ( i + j , j ) % mod * c ( v , siz[u] - j ) % mod * dp[u] % mod ) % mod ;
                }
            }
            tot += siz[u] ;
            for ( int i = 0 ; i <= tot ; ++ i ) {
                dp2[i] = nxt[i] ;
            }
        }
        for ( int i = tot - must ; i >= 0 ; -- i ) {
            dp2[i + 1] = dp2[i] ;
        }
        tot ++ ;
    }
    int all = tot - must ;
    while ( pre[x] != lca ) {
        int z = x ;
        x = pre[x] ;
        for ( int o = H[x] ; ~o ; o = E[o].n ) {
            int u = E[o].v ;
            if ( u == pre[x] || u == z ) continue ;
            int sum = 0 ;
            for ( int i = all ; i >= 0 ; -- i ) {
                int tmp = 1LL * c ( tot - i + siz[u] - 1 , siz[u] - 1 ) * dp[u] % mod ;
                sum = ( sum + dp2[i] ) % mod ;
                dp2[i] = ( 1LL * sum * tmp + 1LL * dp2[i] * c ( tot - i - 1 + siz[u] , siz[u] ) % mod * dp[u] % mod ) % mod ;
            }
            tot += siz[u] ;
        }
        for ( int i = all - 1 ; i >= 0 ; -- i ) {
            dp2[i] = ( dp2[i] + dp2[i + 1] ) % mod ;
        }
        tot ++ ;
    }
    int ans = 0 ;
    for ( int i = 0 ; i <= n ; ++ i ) {
        ans = ( ans + dp2[i] ) % mod ;
    }
    for ( int i = H[lca] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == pre[lca] || v == x || v == y ) continue ;
        ans = 1LL * ans * dp[v] % mod * c ( tot + siz[v] , siz[v] ) % mod ;
        tot += siz[v] ;
    }
    tot ++ ;
    int z = lca ;
    int u = pre[lca] ;
    ans = 1LL * dp[root] * powmod ( dp[z] , mod - 2 ) % mod * ans % mod ;
    return ans ;
}

void solve () {
    init () ;
    for ( int i = 1 ; i < n ; ++ i ) {
        int u , v ;
        scanf ( "%d%d" , &u , &v ) ;
        addedge ( u , v ) ;
        addedge ( v , u ) ;
    }
    ans = 0 ;
    pre[root] = 0 ;
    dfs ( root ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        for ( int j = 1 ; j < i ; ++ j ) {
            ans = ( ans + calc ( i , j ) ) % mod ;
        }
    }
    printf ( "%d\n" , ans ) ;
}

int main () {
    f[0] = vf[0] = 1 ;
    for ( int i = 1 ; i < MAXN ; ++ i ) {
        f[i] = 1LL * f[i - 1] * i % mod ;
        vf[i] = powmod ( f[i] , mod - 2 ) ;
    }
    //freopen ( "1009.in" , "r" , stdin ) ;
    //freopen ( "1009.txt" , "w" , stdout ) ;
    while ( ~scanf ( "%d%d" , &n , &root ) ) solve () ;
    //printf ( "%.5f\n" , ( double ) clock () / CLOCKS_PER_SEC ) ;
    return 0 ;
}