BZOJ 4031: [HEOI2015]小Z的房间

4031: [HEOI2015]小Z的房间

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 878  Solved: 429
[Submit][Status][Discuss]

Description

你突然有了一个大房子，房子里面有一些房间。事实上，你的房子可以看做是一个包含n*m个格子的格状矩形，每个格子是一个房间或者是一个柱子。在一开始的时候，相邻的格子之间都有墙隔着。

你想要打通一些相邻房间的墙，使得所有房间能够互相到达。在此过程中，你不能把房子给打穿，或者打通柱子（以及柱子旁边的墙）。同时，你不希望在房子中有小偷的时候会很难抓，所以你希望任意两个房间之间都只有一条通路。现在，你希望统计一共有多少种可行的方案。

Input

第一行两个数分别表示n和m。

接下来n行，每行m个字符，每个字符都会是’.’或者’*’，其中’.’代表房间，’*’代表柱子。

Output

 一行一个整数，表示合法的方案数 Mod 10^9

Sample Input

3 3
...
...
.*.

Sample Output

15

HINT

 

对于前100%的数据，n,m<=9

 

Source

 

[Submit][Status][Discuss]

 

这就是个霍尔基夫矩阵，哦不，霍基尔夫矩阵，哦不，基尔霍夫矩阵裸题。

 

#include <bits/stdc++.h>

#define int long long

const int mxn = 15;
const int mxm = 105;
const int mod = 1E9;

int n, m, tot;
int mrk[mxn][mxn];
int map[mxn][mxn];
int mat[mxm][mxm];

signed main(void)
{
    scanf("%lld%lld", &n, &m);
    
    for (int i = 1; i <= n; ++i)
    {
        static char s[mxn];
        scanf("%s", s + 1);
        
        for (int j = 1; j <= m; ++j)
            map[i][j] = (s[j] == '.');
    }
    
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (map[i][j])
            {
                mrk[i][j] = ++tot;
                
                {
                    int x = i - 1, y = j;
                    
                    if (map[x][y])
                    {
                        int a = mrk[i][j];
                        int b = mrk[x][y];
                        
                        mat[a][b] = mat[b][a] = -1;
                        
                        ++mat[a][a];
                        ++mat[b][b];
                    }
                }
                
                {
                    int x = i, y = j - 1;
                    
                    if (map[x][y])
                    {
                        int a = mrk[i][j];
                        int b = mrk[x][y];
                        
                        mat[a][b] = mat[b][a] = -1;
                        
                        ++mat[a][a];
                        ++mat[b][b];
                    }
                }
            }
    
    for (int i = 1; i <= tot; ++i)
        for (int j = 1; j <= tot; ++j)
            mat[i][j] = (mat[i][j] + mod) % mod;
            
    int ans = 1;
    
    for (int i = 1; i < tot; ++i)
    {
        for (int j = i + 1; j < tot; ++j)
            if (mat[j][i] > mat[i][i])
                std::swap(mat[i], mat[j]), ans = -ans;
        
        if (mat[i][i] == 0)continue;
        
        for (int j = i + 1; j < tot; ++j)
        {
            while (mat[i][i] && mat[j][i])
            {
                if (mat[i][i] > mat[j][i])
                    std::swap(mat[i], mat[j]), ans = -ans;
                
                int t = mat[j][i] / mat[i][i];
                
                for (int k = i; k < tot; ++k)
                    mat[j][k] = ((mat[j][k] - mat[i][k] * t % mod) % mod + mod) % mod;
            }
            
            if (mat[j][i])std::swap(mat[i], mat[j]), ans = -ans;
        }
    }
    
    ans = (ans + mod) % mod;
    
    for (int i = 1; i < tot; ++i)
        ans = ans * mat[i][i] % mod;
    
    printf("%lld\n", (ans % mod + mod) % mod);
}

 

@Author: YouSiki