矩阵树定理(Matrix Tree)学习笔记

如果不谈证明，稍微有点线代基础的人都可以在两分钟内学完所有相关内容。。

行列式随便找本线代书看一下基本性质就好了。

学习资源：

https://www.cnblogs.com/candy99/p/6420935.html

http://blog.csdn.net/Marco_L_T/article/details/72888138

首先是行列式对几个性质（基本上都是用数学归纳法证）：

1.交换两行（列），行列式取相反数

2.由1.得若存在两行（列）完全相同则行列式为0

3.上（下）三角行列式即主对角线值之积

只有这三条用得上。

然后就可以直接上Matrix Tree定理了：一个无向图的邻接矩阵减去度数矩阵得到的矩阵的任意n-1阶子矩阵的行列式的绝对值等于其有标号生成树的数目。

其中邻接矩阵-度数矩阵即为基尔霍夫矩阵（又称拉普拉斯算子）。

加强版：有向图的树形图（从根可以走到任意点）个数，将上面的“度数矩阵”改为“入度矩阵即可”（见第二份链接）

若求以x为根的外向树数量，则求删去第x行与第x列的n-1阶子矩阵的行列式即可。

关于行列式的算法，按定义朴素跑复杂度是阶乘级别的，利用上面的性质，初等行变换使之成为上三角矩阵即可。（实际上就是高斯消元）。注意高消中基准元要选绝对值最大的，以及注意判0退出。

下面是几道裸题：

SPOJ Highways  裸题

 #include<cmath>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 using namespace std;

 const int N=;
 const double eps=1e-;

 int T,n,m,u,v;
 double a[N][N];

 void Gauss(){
     n--;
     rep(i,,n){
         int r=i;
         rep(j,i+,n) if (fabs(a[j][i])>fabs(a[r][i])) r=j;
         if (fabs(a[r][i]<eps)) { puts(""); return; }
         if (r!=i) rep(k,,n) swap(a[r][k],a[i][k]);
         rep(j,i+,n){
             double t=a[j][i]/a[i][i];
             rep(k,i,n) a[j][k]-=t*a[i][k];
         }
     }
     double ans=;
     rep(i,,n) ans*=a[i][i];
     printf("%.0f\n",abs(ans));
 }

 int main(){
     for (scanf("%d",&T); T--; ){
         scanf("%d%d",&n,&m);
         memset(a,,sizeof(a));
         rep(i,,m) scanf("%d%d",&u,&v),a[u][u]++,a[v][v]++,a[u][v]--,a[v][u]--;
         Gauss();
     }
     return ;
 }

BZOJ4766:

先手工构造出矩阵然后观察规律求出公式。

https://blog.sengxian.com/solutions/bzoj-4766

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 typedef long long ll;

 ll n,m,P;
 ll mod(ll x){ return (x<P) ? x : x-P; }

 ll mul(ll a,ll b){
     ll res=;
     for (; b; b>>=,a=mod(a+a))
         if (b & ) res=mod(res+a);
     return res;
 }

 ll pow(ll a,ll b){
     ll res=;
     for (; b; b>>=,a=mul(a,a))
         if (b & ) res=mul(res,a);
     return res;
 }

 int main(){
     scanf("%lld%lld%lld",&n,&m,&P);
     printf("%lld\n",mul(pow(n,m-),pow(m,n-)));
     return ;
 }

BZOJ4031 裸题

这里又个trick，高斯消元的时候因为模数是个合数不好求逆元，所以用辗转相除的方法做就好了。

就是不停对两行相互进行初等行变换直到其中一行第一个数变为0，这样复杂度是log的，并且保证膜意义下不会出错。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 typedef long long ll;
 using namespace std;

 const int N=,md=;
 int n,m,a[N][N],id[N][N],tot;
 char s[N][N];

 void Gauss(int n){
     int s=;
     rep(i,,n){
         int r=i;
         rep(j,i+,n) if (a[j][i]>a[r][i]) r=j;
         if (!a[r][i]) { puts(""); return; }
         if (i!=r){
             s^=;
             rep(k,i,n) swap(a[i][k],a[r][k]);
         }
         rep(j,i+,n){
             while (a[j][i]){
                 ll t=a[j][i]/a[i][i];
                 rep(k,i,n) a[j][k]=(a[j][k]-t*a[i][k]%md+md)%md;
                 if (!a[j][i]) break;
                 s^=;
                 rep(k,i,n) swap(a[i][k],a[j][k]);
             }
         }
     }
     ll ans=;
     rep(i,,n) ans=ans*a[i][i]%md;
     if (s) ans=(md-ans)%md;
     printf("%lld\n",ans);
 }

 void work(){
     rep(i,,m) rep(j,,n) if (s[i][j]=='.') id[i][j]=++tot;
     rep(i,,m) rep(j,,n) if (id[i][j]){
         int u=id[i][j],v;
         if (i!= && s[i-][j]=='.')
             v=id[i-][j],a[u][u]++,a[v][v]++,a[u][v]--,a[v][u]--;
         if (j!= && s[i][j-]=='.')
             v=id[i][j-],a[u][u]++,a[v][v]++,a[u][v]--,a[v][u]--;
     }
     rep(i,,m*n) rep(j,,m*n) a[i][j]=(a[i][j]+md)%md;
 }

 int main(){
     freopen("bzoj4031.in","r",stdin);
     freopen("bzoj4031.out","w",stdout);
     scanf("%d%d",&m,&n);
     rep(i,,m) scanf("%s",s[i]+);
     work(); Gauss(tot-);
     return ;
 }