基尔霍夫矩阵题目泛做（AD第二轮）

题目1： SPOJ 2832

题目大意：

求一个矩阵行列式模一个数P后的值。p不一定是质数。

算法讨论：

因为有除法而且p不一定是质数，不一定有逆元，所以我们用辗转相除法。

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 205;
typedef long long ll;

int n;
ll p, mat[N][N];

ll det(ll a[N][N]) {
  ll res = 1;

  for(int i = 1; i <= n; ++ i) {
    for(int j = i + 1; j <= n; ++ j) {
      while(a[j][i]) {
        ll t = a[i][i] / a[j][i];

        for(int k = i; k <= n; ++ k)
          a[i][k] = (a[i][k] - a[j][k] * t) % p;
        for(int k = i; k <= n; ++ k)
          swap(a[i][k], a[j][k]);
        res = -res;
      }
    }
    if(a[i][i] == 0) return 0;
    res = 1LL * res * a[i][i] % p;
  }
  return (res + p)  % p;
}

int main() {
  while(~scanf("%d%lld", &n, &p)) {
    for(int i = 1; i <= n; ++ i) {
      for(int j = 1; j <= n; ++ j) {
        scanf("%lld", &mat[i][j]);
        mat[i][j] %= p;
      }
    }
    printf("%lld
", det(mat));
  }
  return 0;
}

题目2： BZOJ 1002 轮状病毒

题目大意：

一棵有规律的树，求其生成树的数量。基尔霍夫矩裸上。

关于矩阵树定理，有一个递推式： f[n] = 3 * f[n - 1] - f[n - 2] + 2;

高精度一下即可。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <iostream>
 
using namespace std;
 
const int rad = 10;
 
int n;
 
struct BigInt {
  int v[1005];
  int len;
 
  BigInt() {
    memset(v, 0, sizeof v);
    len = 0;
  }
 
  friend BigInt operator + (BigInt a, BigInt b) {
    int tmp = max(a.len, b.len);
 
    for(int i = 1; i <= tmp; ++ i) {
      a.v[i] += b.v[i];
      if(a.v[i] >= rad) {
        a.v[i + 1] += a.v[i] / rad;
        a.v[i] %= rad;
      }
    }
    while(a.v[tmp + 1]) tmp ++;
    a.len = tmp;
 
    return a;
  }
 
  friend BigInt operator * (BigInt a, BigInt b) {
    BigInt c;
    int tmp = a.len + b.len;
 
    for(int i = 1; i <= a.len; ++ i) {
      for(int j = 1; j <= b.len; ++ j) {
        c.v[i + j - 1] += a.v[i] * b.v[j];
      }
    }
    for(int i = 1; i <= tmp; ++ i) {
      if(c.v[i] >= rad) {
        c.v[i + 1] += c.v[i] / rad;
        c.v[i] %= rad;
      }
      if(c.v[i]) c.len = i;
    }
 
    return c;
  }
 
  friend BigInt operator * (BigInt a, int k) {
    for(int i = 1; i <= a.len; ++ i) {
      a.v[i] *= k;
    }
    for(int i = 1; i <= a.len; ++ i) {
      a.v[i + 1] += a.v[i] / rad;
      a.v[i] %= rad;
    }
    if(a.v[a.len + 1]) a.len ++;
    return a;
  }
 
  friend BigInt operator - (BigInt a, BigInt b) {
    for(int i = 1; i <= a.len; ++ i) {
      a.v[i] -= b.v[i];
      if(a.v[i] < 0) {
        a.v[i + 1] -= 1;
        a.v[i] += rad;
      }
    }
    while(a.v[a.len] == 0)a.len --;
    return a;
  }
  void getint(int k) {
    while(k) {
      v[++ len] = k % 10;
      k /= 10;
    }
  }
   
  void print() {
    for(int i = len; i >= 1; -- i) {
      printf("%d", v[i]);
    }
  }
}f[105], cst;
 
void Input() {
  scanf("%d", &n);
}
 
void Solve() {
  f[1].getint(1);
  f[2].getint(5);
  cst.getint(2);
  for(int i = 3; i <= n; ++ i) {
    f[i] = f[i - 1] * 3 - f[i - 2] + cst;
  }
}
 
void Output() {
  f[n].print();
}
 
int main() {
  Input();
  Solve();
  Output();
 
  return 0;
}

题目3： SPOJ 104 HighWays

题目大意：

给一张图，求其生成树的个数。

算法讨论：裸上基尔霍夫。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <algorithm>
 
using namespace std;
 
typedef long long ll;
const int N = 15;
 
ll ans;
int n, m;
ll degree[N][N], G[N][N], self[N][N];
 
ll det(ll a[N][N]) {
  ll res = 1;
  
  for(int i = 1; i < n; ++ i) {
    for(int j = i + 1; j < n; ++ j) {
      while(a[j][i]) {
        ll t = a[i][i] / a[j][i];
 
        for(int k = i; k < n; ++ k)
          a[i][k] = (a[i][k] - a[j][k] * t);
        for(int k = i; k < n; ++ k)
          swap(a[i][k], a[j][k]);
        res = -res;
      }
    }
    if(a[i][i] == 0) return 0;
    res = 1LL * res * a[i][i];
  }
  return res;
}
 
void Input() {
  int x, y;
 
  memset(self, 0, sizeof self);
  memset(degree, 0, sizeof degree);
  
  scanf("%d%d", &n, &m);
  for(int i = 1; i <= m; ++ i) {
    scanf("%d%d", &x, &y);
    degree[x][y] ++;
    degree[y][x] ++;
    self[x][x] ++; self[y][y] ++;
  }
  for(int i = 1; i <= n; ++ i) {
    for(int j = 1; j <= n; ++ j) {
      G[i][j] = self[i][j] - degree[i][j];
    }
  }
}
 
void Solve() {
  ans = det(G);
}
 
void Output() {
  printf("%lld
", ans);
}
 
int main() {
  int t;
 
  scanf("%d", &t);
 
  while(t --) {
    Input();
    Solve();
    Output();
  }
 
  return 0;
}

题目4： BZOJ 4031 [HEOI 2015] 小Z的房间

题目大意：并没有搞懂。只是抄的。河北的题还真是够呛。（PS：我是河北的）

算法讨论：裸上Matrix-Tree定理吧。

#include <bits/stdc++.h>

using namespace std;

const int N = 15;
const int mod = 1e9;
typedef long long ll;

int n, m, cnt;
int p[N][N]; ll a[N * N][N * N];
int dx[]={0, 0, 1, -1};
int dy[]={1, -1, 0, 0};
char maze[N][N];

ll det() {
  ll res = 1;

  for(int i = 1; i < cnt; ++ i)
    for(int j = 1; j < cnt; ++ j)
      a[i][j] = (a[i][j] + mod) % mod;
  for(int i = 1; i < cnt; ++ i) {
    for(int j = i + 1; j < cnt; ++ j) {
      while(a[j][i]) {
        ll t = a[i][i] / a[j][i];
        
        for(int k = i; k < cnt; ++ k)
          a[i][k] = (a[i][k] - a[j][k] * t % mod + mod) % mod;
        for(int k = i; k < cnt; ++ k)
          swap(a[i][k], a[j][k]);
        res = -res;
      }
    }
    if(a[i][i] == 0) return 0;
    res = 1LL * res * a[i][i] % mod;
  }
  return (res + mod) % mod;
}

int main() {
  scanf("%d%d", &n, &m);
  for(int i = 1; i <= n; ++ i) {
    scanf("%s", maze[i] + 1);
  }
  for(int i = 1; i <= n; ++ i) 
    for(int j = 1; j <= m; ++ j)
      if(maze[i][j] == '.')
        p[i][j] = ++ cnt;
  for(int i = 1; i <= n; ++ i) {
    for(int j = 1; j <= m; ++ j) {
      if(maze[i][j] != '.') continue;
      for(int k = 0; k < 4; ++ k) {
        int nx = dx[k] + i, ny = dy[k] + j;

        if(nx < 1 || ny < 1 || nx > n || ny > m || maze[nx][ny] != '.') continue;
        int u = p[i][j], v = p[nx][ny];

        a[u][u] ++; a[u][v] --;
      }
    }
  }
  printf("%lld
", det());
  return 0;
}

题目5： Uva 10766

题目大意：

求一个有根树的生成树的数量。

算法讨论：

其实这个有根和无根是一样的。直接做就行。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 55;

int n, m, kk;
bool lk[N][N];
ll a[N][N];

ll det() {
  ll res = 1;
  
  for(int i = 1; i < n; ++ i) {
    for(int j = i + 1; j < n; ++ j) {
      while(a[j][i]) {
        ll t = a[i][i] / a[j][i];

        for(int k = i; k < n; ++ k)
          a[i][k] = a[i][k] - a[j][k] * t;
        for(int k = i; k < n; ++ k)
          swap(a[i][k], a[j][k]);
        res = -res;
      }
    }
    if(a[i][i] == 0) return 0;
    res = res * a[i][i];
  }

  return abs(res);
}

int main() {
  int u, v;
  
  while(~scanf("%d%d%d", &n, &m, &kk)) {
    memset(lk, false, sizeof lk);
    memset(a, 0, sizeof a);
    for(int i = 1; i <= m; ++ i) {
      scanf("%d%d", &u, &v);
      lk[u][v] = lk[v][u] = true;
    }
    for(int i = 1; i <= n; ++ i) {
      int cnt = 0;

      for(int j = 1; j <= n; ++ j) {
        if(i != j && !lk[i][j]) {
          a[i][j] = -1;
          ++ cnt;
        }
      }
      a[i][i] = cnt;
    }
    printf("%lld
", det());
  }

  return 0;
}

题目6： BZOJ1016 && JSOI2008最小生成树计数

题目大意：

求一个图的最小生成树的个数。

算法讨论：

将边权从小到大SORT。然后对于相同边权的做一次处理进行缩点。如果缩点后出现多个联通块，有两种方法：对每个联通块做Matrix-Tree，然后相乘，或者在两个联通块加一个桥，这样方案数不会受影响。

坑点就是最后如果有形不成树的情况。

代码：

#include <cstdlib>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;
const int N = 100 + 5;
const int M = 1000 + 5;
const int mod = 31011;
typedef long long ll;

int n, m, tim, cnt;
ll A[N][N], ans = 1;
int fa[N], lab[N], repos[N], f2[N];

struct Edge {
    int u, v, d;
    bool operator < (const Edge &k) const {
        return d < k.d;
    }
}e[M];
vector <Edge> p[N];

void Init() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; ++ i) {
        scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].d);
    }
}

ll Det(ll a[N][N], int ns) {
    ll res = 1;
    for(int i = 1; i < ns; ++ i) {
        for(int j = i + 1; j < ns; ++ j) {
            while(a[j][i]) {
                ll t = a[i][i] / a[j][i];
                for(int k = i; k < ns; ++ k)
                    a[i][k] = (a[i][k] - a[j][k] * t);
                for(int k = i; k < ns; ++ k)
                    swap(a[i][k], a[j][k]);
                res = -res;
            }
        }
        if(a[i][i] == 0) return 0;
        res = res * a[i][i];
    }    
    return res;
}

int find(int *f, int x) {
    return f[x] == x ? x : (f[x] = find(f, f[x]));
}

void Work(vector <Edge> &v) {
    vector <Edge> :: iterator it;
    int poi = 0;
    ++ tim;
    for(it = v.begin(); it != v.end(); ++ it) {
        if(lab[fa[(*it).u]] != tim) {
            lab[fa[(*it).u]] = tim; 
            repos[fa[(*it).u]] = ++ poi;
        }
        if(lab[fa[(*it).v]] != tim) {
            lab[fa[(*it).v]] = tim;
            repos[fa[(*it).v]] = ++ poi;
        }
    }    
    for(int i = 1; i <= poi; ++ i) 
        for(int j = 1; j <= poi; ++ j)
            A[i][j] = 0;
    for(it = v.begin(); it != v.end(); ++ it) {
        -- A[repos[fa[(*it).u]]][repos[fa[(*it).v]]];
        -- A[repos[fa[(*it).v]]][repos[fa[(*it).u]]];
        ++ A[repos[fa[(*it).u]]][repos[fa[(*it).u]]];
        ++ A[repos[fa[(*it).v]]][repos[fa[(*it).v]]];
    }
    ans = ans * Det(A, poi) % mod;
}

void Calc(int l, int r) {
    for(int i = l; i <= r; ++ i) {
        f2[fa[e[i].u]] = fa[e[i].u];
        f2[fa[e[i].v]] = fa[e[i].v];
        p[fa[e[i].u]].clear();
        p[fa[e[i].v]].clear();
    }
    for(int i = l; i <= r; ++ i) {
        f2[find(f2, fa[e[i].u])] = find(f2, fa[e[i].v]);
    }
    for(int i = l; i <= r; ++ i) {
        if(fa[e[i].u] != fa[e[i].v]) {
            p[find(f2, fa[e[i].u])].push_back(e[i]);
        }
    }
    for(int i = l; i <= r; ++ i) {
        if(!p[fa[e[i].u]].empty()) {
            Work(p[fa[e[i].u]]), p[fa[e[i].u]].clear();
        }
        if(!p[fa[e[i].v]].empty()) {
            Work(p[fa[e[i].v]]), p[fa[e[i].v]].clear();
        }
    }
}

void Solve() {
    sort(e + 1, e + m + 1);
    cnt = n;
    for(int i = 1; i <= n; ++ i) fa[i] = i;
    for(int i = 1; i <= m && cnt > 1;) {
        int j = i;
        for(; e[j].d == e[i].d && j <= m; ++ j) {
            find(fa, e[j].u); find(fa, e[j].v);
        }
        Calc(i, j - 1);
        for(int k = i; k < j; ++ k) {
            int fx = find(fa, e[k].u), fy = find(fa, e[k].v);
            if(fx != fy) {
                fa[fx] = fy;
                cnt --;
            }
        }
        i = j;
    }
    if(cnt != 1) ans = 0;
    printf("%lld
", ans % mod);
}

#define stone_eee
int main() {
#ifndef stone_
    freopen("mst.in", "r", stdin);
    freopen("mst.out", "w", stdout);
#endif

    Init();
    Solve();

#ifndef stone_
    fclose(stdin); fclose(stdout);
#endif
    return 0;
}