网站图片用什么做/seo是什么部位

原题链接：http://www.lydsy.com/JudgeOnline/problem.php?id=4031

 

Description

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

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

Input

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

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

Output

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

Sample Input

3 3
...
...
.*.

Sample Output

15

HINT

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

 

 

 

题意概述：
　　给出一个矩阵，由N*M个格子组成，这个矩阵中有'*'和'.'。可以把矩阵中方格的一些边破坏掉，但是不可以破坏这个矩阵的边缘和与'*'相邻的边。现在询问由多少种方案让所有的'.'连通并且任意两个'.'之间只有唯一一条路径。换言之要求求这个矩阵在规则下可以形成的生成树的数量。答案mod10^9。
　　N,M<=9.

 

分析：
　　实际上当你了解了矩阵树定理了之后这TM就是一个裸题......
　　只是取mod的时候有一点魔性啊......mmj我在脑补些什么毛病又来了！！！！具体的操作方法是辗转相除，利用辗转相除的原理弄掉第i项系数。根据行列式的性质，可以发现相除只会改变行列式的正负情况（因为有交换两行的操作），而并不会改变行列式的绝对值。因此我们只需要维护行列式的值的符号位就可以了。
　　注意一下给新图编号的时候要注意不要给'*'编号，不然这个编号不连续图就......不连通了......你就得到了一个0分的优秀算法！！！（除非这个图本来不连通你可以有个10分之类的）
　　时间复杂度O((N*M)^3)（因为辗转相除的原因带上常数log）。

 

getting新姿势—行列式

定义：

　　一个方阵的行列式的形式化定义为Sigma{ (-1)^t*a_1p1*a_2p2*...*a_npn | p₁,p₂,...,p_n为1~n的全排列，t表示这个排列中的逆序对数 }，也就是说行列式实际上是一个标量。

性质：

　　1.首先定义一个矩阵A，记这个矩阵的转置为A^T（把矩阵中元素ai,j变到aj,i），记方阵A的行列式为|A|，那么有|A|=|A^T|。

　　证明：首先看到定义式中a的下标，可以发现二元组下标(1,p1),(2,p2),...,(n,pn)，将其按照第二维p排序之后，每消失一个关于第二维的逆序对就会出现一个关于第一维的逆序对，因此Sigma集中的每一种情况放到转置矩阵之中a的乘积没有变，而逆序对数也没有变，得证。

　　2.如果将A中的两行互换得到A'，那么有|A|=-|A'|。

　　证明：首先，操作之后可以发现最后产生的效果实际上就是在Sigma集中交换了两个元素的位置，即对于原Sigma集中的每一个状态一定能够在新的Sigma集中找到唯一对应的一个状态使得Sigma集中所有元素的值没有变，但是只有两个元素的下标发生了交换。而在一个序列中交换两个元素的位置一定会让逆序对数的奇偶性发生变化（易证，懒得写了ORZ），因此前后对应状态对Sigma集产生的贡献抵消，最终加起来的结果为0.

　　3.把A的一行所有元素全部乘以k，行列式的值也要乘以k。

　　证明：考虑定义式，很容易发现这个性质。

　　4.两个矩阵只有一行不同，那么他们的行列式之和等于两个矩阵不同的那一行相加之后得到的矩阵的行列式。

　　证明：考虑一下乘法分配律，结合定义式，易证。

　　5.将矩阵的某一行中的所有元素对应加上另外一行乘以某个数之后的所有元素，得到的矩阵行列式等于原矩阵的行列式。

　　证明：首先可以把新的矩阵拆开。对于一个矩阵中的两行，如果有一行是另一行的倍数，那么这个矩阵的行列式为0。把常数踢出去，考虑Sigma集中的一种情况，可以找到另外一种情况使得Sigma集中的所有元素值都不变但是某两个值的下标交换，这两个值对应的来源就是两个有倍数关系的行，交换下标之后逆序对数奇偶性变化，贡献抵消，最终行列式值为0。得证。
　　6.一个上三角矩阵的行列式的值就是这个矩阵主对角线上的所有值的乘积。

　　证明：很容易发现这种情况下只有p1,p2,...,pn分别为1,2,...,n的时候才有贡献。

　　利用以上6个性质得到的结论，尤其是第5,6个，可以使用高斯消元的方法把整个矩阵消成一个上三角矩阵，这个上三角矩阵主对角线上的所有数相乘就是这个矩阵行列式的值。

应用：

 

基尔霍夫矩阵！

　　对于一个无向连通图，构造一个度数矩阵A（实际上是一个方阵），当i=i的时候a[i][i]=du[i]，否则为0。再构造一个邻接矩阵G，令这张图的基尔霍夫矩阵为C=A-G，那么这张图的生成树数量就是基尔霍夫矩阵任意余子式Mi,i绝对值（余子式Mi,i指的是将矩阵中的第i行i列的元素去掉之后得到的矩阵的行列式）。

　　emmmmmm......其他的之后来填坑。

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
using namespace std;
const int maxn=12;
const int maxm=90;
const int mo=1000000000;
typedef long long LL;

int N,M,tot;
char mp[maxn][maxn];
int A[maxm][maxm],C[maxm][maxm],G[maxm][maxm],id[maxn][maxn];

void data_in()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++) scanf("%s",mp[i]+1);
}
int Gauss(int a[maxm][maxm])
{
    int flag=1;
    for(int i=1;i<tot;i++){
        int tmp=i;
        for(int j=i+1;j<tot;j++)
            if(a[j][i]){ tmp=j; break; }
        for(int k=i;k<tot;k++) swap(a[i][k],a[tmp][k]);
        if(tmp!=i) flag=-flag;
        for(int j=i+1;j<tot;j++){
            while(a[j][i]){
                int t=a[j][i]/a[i][i];
                for(int k=i;k<tot;k++) a[j][k]=(a[j][k]-1ll*t*a[i][k]%mo+mo)%mo;
                if(!a[j][i]) break;
                flag=-flag;
                for(int k=i;k<tot;k++) swap(a[j][k],a[i][k]);
            }
        }
    }
    for(int i=1;i<tot;i++) flag=(1ll*flag*a[i][i])%mo;
    return (flag+mo)%mo;
}
void work()
{
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++)
        if(mp[i][j]!='*') id[i][j]=++tot;
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++){
        if(i-1&&mp[i-1][j]!='*') C[id[i][j]][id[i-1][j]]=1,A[id[i][j]][id[i][j]]++;
        if(j-1&&mp[i][j-1]!='*') C[id[i][j]][id[i][j-1]]=1,A[id[i][j]][id[i][j]]++;
        if(i+1<=N&&mp[i+1][j]!='*') C[id[i][j]][id[i+1][j]]=1,A[id[i][j]][id[i][j]]++;
        if(j+1<=M&&mp[i][j+1]!='*') C[id[i][j]][id[i][j+1]]=1,A[id[i][j]][id[i][j]]++;
    }
    for(int i=1;i<=tot;i++)
    for(int j=1;j<=tot;j++)
        G[i][j]=A[i][j]-C[i][j];
    printf("%d\n",Gauss(G));
}
int main()
{
    data_in();
    work();
    return 0;
}