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;
}