UVA11741 轮廓线动态规划（矩阵加速）

本来我以为看了刘汝佳的讲解之后我已经懂了轮廓线dp，直到做了这道题，才发现，你认为你懂了一种思想，只是你没有更深的了解和应用这种思想而已。
做了这道题，终于比较懂原理了，对矩阵的用法也加深了好多，同时明白了，动态规划中状态的转移和图论有着很相似的地方。
每个状态可以达到的状态连一条边，如果在某个阶段，存在一种转移方式，所有的状态都按照这种转移方式来转移，那么就可以把这种转移方式存到图上，一般用矩阵（便于加速），而如果存在多个这样的阶段，那么转移方式不唯一，那么我们可以设多种转移矩阵，然后把它们连乘起来，就相当于在图上做dp的转移，并且在不同的阶段乘不同的矩阵。

这道题的思路就是这样的，一共有三种转移阶段，每种矩阵分别对应A,B,C
那么在某一行 如果不存在坏点，乘法就是固定的格式B*A*A*A
如果存在坏点那么就可能是B*A*C*A
或者C*A*A*A，诸如此类
然后因为坏点相对整个矩阵来说 非常少，那么可以只处理坏点存在的行，然后其他空白行利用矩阵乘法的结合律，处理出tmp = B*A*A*A，然后就可以快速幂加速了

要注意的是，pre初始化为-1，因为第一行0是会处理的，他之前就应该是-1

//
//  Created by Running Photon on 2016-03-01
//  Copyright (c) 2015 Running Photon. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <sstream>
#include <set>
#include <vector>
#include <stack>
#define ALL(x) x.begin(), x.end()
#define INS(x) inserter(x, x,begin())
#define ll long long
#define CLR(x) memset(x, 0, sizeof x)
using namespace std;
const int inf = 0x3f3f3f3f;
const ll MOD = 1e7 + 7;
const int maxn = 1e6 + 10;
const int maxv = (1 << 4) + 5;
const double eps = 1e-9;

struct Matrix {
    ll mat[maxv][maxv];
    Matrix() {CLR(mat);}
    void clear() {
        CLR(mat);
    }
    void print(int maxx) {
        for(int i = 0; i < maxx; i++) {
            for(int j = 0; j < maxx; j++) {
                printf("%lld ", mat[i][j]);
            }
            puts("");
        }
        puts("");
    }
    Matrix operator* (Matrix& rhs) {
        Matrix ret;
        ret.clear();
        for(int i = 0; i < maxv; i++) {
            for(int j = 0; j < maxv; j++) {
                for(int k = 0; k < maxv; k++) {
                    ret.mat[i][j] = (ret.mat[i][j] + mat[i][k] * rhs.mat[k][j]) % MOD;
                }
            }
        }
        return ret;
    }
    Matrix operator^ (ll n) {
        Matrix ret;
        Matrix a = *this;
        ret.clear();
        for(int i = 0; i < maxv; i++) {
            ret.mat[i][i] = 1;
        }
        while(n) {
            if(n & 1) ret = ret * a;
            a = a * a;
            n >>= 1;
        }
        return ret;
    }
};
int n, m, R;
vector <int> vis;
typedef pair <int, int> sta;
map <sta, int> mp;
void update(int pre, int now, Matrix& ret) {
    if(now & (1 << m)) ret.mat[pre][now ^ (1 << m)] = (ret.mat[pre][now ^ (1 << m)] + 1) % MOD;
}
int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
//  ios_base::sync_with_stdio(0);
    int cas = 0;
    while(scanf("%d%d%d", &m, &n, &R) != EOF && (n || m || R)) {

        vis.clear();
        mp.clear();
        for(int i = 0; i < R; i++) {
            int r, c;
            scanf("%d%d", &c, &r);
            mp[sta(r, c)]++;
            vis.push_back(r);
        }
        vis.push_back(n - 1);
        sort(ALL(vis));
        vis.resize(unique(ALL(vis)) - vis.begin());
//        for(int i = 0; i < vis.size(); i++) {
//            printf("%d ", vis[i]);
//        }
//        puts("");
        int nxt = 0;
        Matrix S, A, B, C;
        for(int state = 0; state < 1 << m; state++) {
            for(int i = 0; i < 3; i++) {
                if(!i) {
                    update(state, (state << 1), A);
                    if(!((1 << m - 1) & state)) update(state, (state << 1) ^ (1 << m) ^ 1, A);
                    if(!(state & 1)) update(state, (state << 1) ^ 3, A);
                }
                else if(i == 1) {
                    update(state, (state << 1), B);
                    if(!((1 << m - 1) & state)) update(state, (state << 1) ^ (1 << m) ^ 1, B);
                }
                else if(i == 2) {
                    update(state, (state << 1) ^ 1, C);
                }
            }
        }
        Matrix tmp;
        for(int i = 0; i < 1 << m; i++) {
            tmp.mat[i][i] = 1;
            S.mat[i][i] = 1;
        }
        tmp = tmp * B;
        for(int i = 0; i < m - 1; i++) {
            tmp = tmp * A;
        }
        int pre = -1;
        for(int h = 0; h < vis.size(); h++) {
            int i = vis[h];
//            printf("i = %d  pre = %d\n", i, pre);
            if(pre < i) {
                Matrix re = tmp;
                re = re ^ (i - pre - 1);
                S = S * (re);
                pre = i;
            }
            for(int j = 0; j < m; j++) {
                if(mp.count(sta(i, j))) {
                    S = S * C;
                }
                else if(!j || mp.count(sta(i, j - 1))) {
                    S = S * B;
                }
                else S = S * A;
            }
        }

//        tmp.print(1 << m);
//        A.print(1 << m);
//        B.print(1 << m);
//        C.print(1 << m);
//        S.print(1 << m);
        printf("Case %d: %lld\n", ++cas, S.mat[(1 << m) - 1][(1 << m) - 1]);
    }

    return 0;
}