UVA 11741 Ignore the Blocks

题目链接：http://vjudge.net/problem/UVA-11741

题意：给一个n*m的棋盘，有k个坏格子，现在用1*2的骨牌覆盖全部的好格子，问有多少种方案。m<=4 , n <= 1e8 , k <= 100。

思路：由于n很大 ， k范围很小，我们按照坏格子所在的行分阶段，相邻的两个坏格子之间的好格子用矩阵快速幂去计算。

可以维护每个状态的方案数，即一个数组(每行最多16个状态，0~15)。当前状态的行号是now , 找到下一个坏格子的行号line，矩阵快速幂计算好格子转移矩阵的(line-now-1)次幂，再将状态转移到下一个坏行前一行时的状态，最后状态再到坏行。循环把所有坏行处理掉即可。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <stack>
#include <map>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <utility>
using namespace std;

#define rep(i,j,k) for (int i=j;i<=k;i++)
#define Rrep(i,j,k) for (int i=j;i>=k;i--)

#define Clean(x,y) memset(x,y,sizeof(x))
#define LL long long
#define ULL unsigned long long
#define inf 0x7fffffff
#define mod 10000007

int m , n , k , uplim;
int tot;
pair<int,int> g[109];
pair<int,int> line[109];
vector<int> S[20][20];

struct matrix
{
    LL a[16][16];
    void clear()
    {
        Clean(a,0);
    }
    void E()
    {
        rep(i,0,uplim)
            rep(j,0,uplim) a[i][j] = i==j ;
    }
}p1;


bool check( int s1 , int s2 , int uplim )
{
    int t = s1 & s2; //t = 0 , 3 , 6 , 12 , 15 时是偶数个1联通 ， 除了9之外的3的倍数
    //t表示下面行横放的状态
    // 下面横放表示为两个1 , 竖放表示为一个1,但上面那行对应位置必须为0
    if ( (s1 | s2 ) == uplim && t != 9 && t % 3 == 0 ) return true;
    return false;
}

void cal()  //处理好格子的转移矩阵  和
{
    p1.clear(); //无坏格子时的转移矩阵
    rep(i,0,uplim) //i表示上面行的放置状态
        rep(j,0,uplim)//j表示下面的放置状态，且j放完后，i是满的
        if ( check(i,j,uplim) ) p1.a[i][j] = 1; //i状态可以到j状态

    //S[i][j]表示上面行放置状态为i时 ， 下面行的坏点状态为j时 ， 可以通过放骨牌转变成哪些状态
    rep(i,0,uplim)
        rep(j,1,uplim)
        {
            S[i][j].clear();
            if ( ( i | j ) != i ) continue;
            rep(k,0,uplim)//j必须为i的子集 ， 否则不能通过竖放填充i的空格部分
            if ( ( j | k ) == k && check( i , k-j , uplim ) ) S[i][j].push_back( k );//j必须为k的子集 ， k为在j状态的基础上放置骨牌
            // k-j就为多放置的部分
        }
}

void init()
{
    rep(i,1,k)
    {
        scanf("%d%d",&g[i].second,&g[i].first);
        g[i].first++ , g[i].second++;
    }
    uplim = (1<<m) - 1; //行放满时的状态
    sort( g + 1 , g + 1 + k );//将坏点按照行从小到大排序
    tot = 0;//坏行的数量
    int temp = g[1].first;
    int i = 1;
    while(i<=k) //把所有的坏点按行分类 ， 维护到line里面  line.first 表示此行的行号, second表示此行的状态
    {
        int state = 0;//记录当前坏行的状态,即哪些格子是坏的
        while( g[i].first == temp ) state |= 1<<(g[i].second-1) , i++;
        tot++;
        line[tot].first = temp , line[tot].second = state;
        temp = g[i].first;
    }
    tot++ , line[tot].first = n + 1;//方便后面计算答案
    cal();
}

matrix multi( matrix x , matrix y )//矩阵乘法
{
    matrix ans;
    for( int i = 0; i <= uplim; i++ )
        for( int j = 0; j <= uplim; j++ )
        {
            ans.a[i][j] = 0;
            for( int k = 0; k <= uplim; k++ ) ans.a[i][j] = ( ans.a[i][j] + x.a[i][k] * y.a[k][j] % mod ) % mod;
        }
    return ans;
}

matrix pow_multi( int n ) //p1转移矩阵的n次幂
{
    matrix a,b;
    a.E();
    b = p1;
    while( n )
    {
        if ( n & 1 ) a = multi( a , b );
        b = multi( b , b );
        n >>= 1;
    }
    return a;
}

int solve()
{
    LL ans[20];
    LL temp[20];
    rep(i,0,uplim) ans[i] = temp[i] = 0;
    int lastline = 0;
    ans[uplim] = 1;//初始第0行的状态
    matrix mid;

    rep(i,1,tot)
    {
        if ( line[i].first - lastline - 1 ) //如果之间有好行
        {
            mid = pow_multi( line[i].first - lastline - 1 );
            rep(ii,0,uplim)//手动转移一下 ans * mid => 新状态
            {
                temp[ii] = 0;
                rep(jj,0,uplim)
                {
                    temp[ii] += ans[jj] * mid.a[jj][ii];
                    if ( temp[ii] >= mod ) temp[ii] %= mod;
                }
            }
            rep(ii,0,uplim) ans[ii] = temp[ii];
        }
        lastline = line[i].first;
        if ( i == tot ) break;
        int state = line[i].second;
        rep(ii,0,uplim) temp[ii] = 0;
        rep(ii,0,uplim) //手动转移当前状态 + 一行坏行后的状态
        if ( ans[ii] && S[ii][state].size() > 0 ) //S[i][j][k]表示前一行状态为i，坏行的状态为j,可以通过放骨牌方成k状态
            for( int jj = 0; jj < S[ii][state].size(); jj++ ) temp[S[ii][state][jj]] = ( temp[S[ii][state][jj]] + ans[ii] ) % mod;
        rep(ii,0,uplim) ans[ii] = temp[ii];
    }

    return ans[uplim];
}

int main()
{

    int cas = 0;
    while( scanf("%d%d%d",&m,&n,&k) == 3 )
    {
        if ( n + m + k == 0 ) break;
        init();
        printf("Case %d: %d\n",++cas,solve());
    }

    return 0;
}