Matrix-tree定理(求生成樹的個數)

Matrix-tree定理：對於一個無向圖 G ，它的生成樹個數等於其基爾霍夫Kirchhoff矩陣任何一個N-1階主子式的行列式的絕對值。證明：https://blog.csdn.net/can919/article/details/86540819#_58

 

拉普拉斯矩陣(Laplacian matrix)也可叫做基爾霍夫矩陣: 摘抄自->數學中的各種矩陣大總結

拉普拉斯矩陣是圖論中用到的一種重要矩陣，給定一個有n個頂點的圖 G=(V,E)，其拉普拉斯矩陣被定義為 L = D-A，其中為圖的度矩陣，為圖的鄰接矩陣。例如，給定一個簡單的圖，如下（例子來自wiki百科）：

把此“圖”轉換為鄰接矩陣的形式，記為A：

 

 

 

把W的每一列元素加起來得到N個數，然后把它們放在對角線上（其它地方都是零），組成一個N×N的對角矩陣，記為度矩陣D，如下圖所示。其實度矩陣（對角線元素）表示的就是原圖中每個點的度數，即由該點發出的邊之數量。

 

 

 

根據拉普拉斯矩陣的定義L = D-A，可得拉普拉斯矩陣L 為：

 

 

 

顯然，拉普拉斯矩陣都是對稱的。此外，另外一種更為常用的拉普拉斯矩陣形式是正則化的拉普拉斯矩陣（Symmetric normalized Laplacian），定義為：

 

 

 

 

該矩陣中的元素由下面的式子給出：

 

 

 

 //-----------------------------------------------------------------------------

// 暴力求行列式時間復雜度為 O(N!×N)

//所以要用到高斯消元求矩陣的行列式O(n³) (高斯消元視頻講解很好理解)

//一般方法高斯消元求行列式

// #define rep(i, n) for(int i=0;i!=n;++i)

// #define Rep(i, sta, n) for(int i=sta;i!=n;++i)

int det(int c[][MAXN], int n) {// 高斯消元求上三角矩陣    
    int ans = 1;
    rep(i, n) rep(j, n) c[i][j] %= mod;
    rep(i, n) {
        Rep(j, i+1, n) {
            while(c[j][i]) {// 類似輾轉相除，可理解為算出c[i][i]和c[j][i]首次為0時把起賦值給c[j][i]()
                int t = c[i][i]/c[j][i];
                Rep(k, i, n) c[i][k] = (c[i][k]-c[j][k]*t)%mod;
                swap(c[i], c[j]);
                ans  = -ans;
            }    
        }
        if(!c[i][i]) return 0;
        ans = ans*c[i][i]%mod;
    }
    return (ans+mod)%mod;
}

// hdu 4305

代碼參考地->😭

// 這題對結果模10007(素數) 所以能在高斯消元中用逆元↓↓↓

/*
 * @Promlem: 
 * @Time Limit: ms
 * @Memory Limit: k
 * @Author: pupil-XJ
 * @Date: 2019-10-20 14:10:38
 * @LastEditTime: 2019-10-21 16:25:00
 */
#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define rep(i, n) for(int i=0;i!=n;++i)
#define per(i, n) for(int i=n-1;i>=0;--i)
#define Rep(i, sta, n) for(int i=sta;i!=n;++i)
#define rep1(i, n) for(int i=1;i<=n;++i)
#define per1(i, n) for(int i=n;i>=1;--i)
#define Rep1(i, sta, n) for(int i=sta;i<=n;++i)
#define L k<<1
#define R k<<1|1
#define mid (tree[k].l+tree[k].r)>>1
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;

inline int read() {
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

const int MAXN  = 300+5;
const int mod = 10007;

struct node {
    int x, y;
} p[MAXN];

int inv[mod];// inv[i]表示i在%mod下的逆元
void init() {// 求逆元(mod質素 才能用遞推--素數篩選)
    inv[1] = 1;
    Rep(i, 2, mod) inv[i] = (mod-mod/i)*inv[mod%i]%mod;
}

inline int det(int c[][MAXN], int n) {// 高斯消元求上三角矩陣
    int i, j, k, ans = 1;
    for(i = 0; i != n; ++i) {
        for(j = 0; j != n; ++j) {
            c[i][j] = (c[i][j]%mod+mod)%mod;
        }
    }
    for(i = 0; i != n; ++i) {
        for(j = i; j != n; ++j) if(c[i][j]) break;// 找出第i行起第i列不為0的行
        if(i != j) swap(c[i], c[j]);
        ans = ans*c[i][i]%mod;
        for(j = i+1; j != n; ++j) {// 第j行第i列變為0
            int d = c[j][i]*inv[c[i][i]]%mod;// c[j][i]-d*c[i][i] = 0
            for(k = i; k != n; ++k) {// (c[j][i]->0同時其它c[j][k]減去d*c[i][k], k=i+1 也行,因為k=i沒必要)
                c[j][k] = (c[j][k]-d*c[i][k]%mod+mod)%mod;
            }
        }
    }
    return ans;
}

inline double get_dis(int i, int j) {
    return sqrt((double)((p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y)));
}

inline bool same(int i, int j, int k) {
    return (p[j].x-p[i].x)*(p[k].y-p[i].y) == (p[j].y-p[i].y)*(p[k].x-p[i].x)
        && (p[k].x>p[i].x&&p[k].x<p[j].x || p[k].x>p[j].x&&p[k].x<p[i].x);
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int T;
    T = read();
    int n, r, mat[MAXN][MAXN];
    init();
    while(T--) {
        n = read(); r = read();
        rep(i, n) rep(j, n) mat[i][j] = 0;
        rep(i, n) p[i].x = read(), p[i].y = read();
        rep(i, n) {
            Rep(j, i+1, n) {
                if(get_dis(i, j) <= r) {
                    bool ok = true;
                    rep(k, n) if(k != i && k != j && same(i, j, k)) {
                        ok = false; break;
                    }
                    if(ok) {// 構造Kirchhoff矩陣
                        mat[i][j] = mat[j][i] = -1;
                        ++mat[i][i]; ++mat[j][j];
                    }
                }
            }
        }
        int ans = det(mat, n-1);// Matrix-tree定理
        if(ans == 0) cout << "-1\n";
        else cout << ans << "\n";
    }
    return 0;
}