CSU1805(BEST theorem,定理题）

题目链接

matrix-tree theorem介绍

Best theorem

题目大意：求一个只有三个点的无向图从1出发经过所有边一次回到1的不同路径树。

分析：先膜一下叉姐，叉姐说代码20行，我硬是改了半天写了60行。（果真弱渣）
首先可以看出，如果把每条边标上方向，那么形成的有向图的答案就是1的度数乘欧拉回路的条数。
其中欧拉回路的条数用Best theorem算，等于以1为根的树形图的个数乘每个点度数减1的阶乘。
而其中以1为根的树形图的个数可以用matrix-tree theorem列个度数矩阵减掉邻接矩阵的矩阵求去掉i行i列的子式的行列式得到。
那么我们回来想形成的有向图的方案数就用组合数算一下就可以了。

代码：

//
//  main.cpp
//  C
//
//  Created by 黄宇凡 on 9/5/16.
//  Copyright © 2016 黄宇凡. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 1e5 + 5;
typedef long long ll;
const ll mod = 1e9 + 7;
ll fac[maxn],inv[maxn];

ll pow_mod(ll a,ll n){
    ll ret = 1;
    while(n > 0){
        if(n & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        n >>= 1;
    }
    return ret;
}

void init(){
    fac[0] = 1; for(int i = 1;i < maxn;i++) fac[i] = fac[i - 1] * (ll)i %mod;
    inv[0] = 1;for(int i = 1;i < maxn;i++) inv[i] = pow_mod(fac[i],mod - 2)% mod;
}

ll A[3][3];

ll C(ll n,ll m){
    return fac[n] * inv[n - m] % mod * inv[m] % mod;
}

ll cal(){
    return (A[1][1] * A[2][2] % mod - A[1][2] * A[2][1] % mod + mod) % mod;
}

int main(int argc, const char * argv[]) {
    int a,b,c;
    init();
    while(scanf("%d%d%d",&a,&b,&c) != EOF){
        swap(b,c);
        if((a + c) & 1 || (a + b) & 1 || (b + c) & 1){
            cout << 0 << endl;
            continue;
        }
        ll ans = 0;
        for(int i = 0;i <= a;i++){
            memset(A,0,sizeof(A));
            A[0][0] = (a + c) / 2;
            A[1][1] = (a + b) / 2;
            A[2][2] = (b + c) / 2;
            A[0][1] = -i;
            A[1][0] = -(a - i);
            A[0][2] = -(A[0][0] - i);
            A[1][2] = -(A[1][1] + A[1][0]);
            A[2][1] = -(b + A[1][2]);
            A[2][0] = -(c + A[0][2]);
            if(A[2][0] > 0 || A[2][1] > 0 || A[1][2] > 0 || A[0][2] > 0) continue;
            ans = (ans + C((ll)a,i) * C((ll)b,-A[1][2]) % mod * C((ll)c,-A[2][0]) % mod * cal() % mod * fac[A[0][0] - 1] % mod  * fac[A[1][1] - 1] % mod * fac[A[2][2] - 1] % mod * A[0][0]% mod)% mod;
        }
        cout << ans << endl;
    }
    return 0;
}