ZOJ 3256 Tour in the Castle 插头DP 矩阵乘法

题解　　

　　这题是一道非常好的插头题，与一般的按格转移的题目不同，由于m很大，要矩阵乘法，这题需要你做一个按列转移的插头DP。

　　按列转移多少与按格转移不同，但大体上还是基于连通性进行转移。每一列只有右插头是对下一列的转移有影响的，那么我们只需要记录每一列的右插头的连通情况，用最小表示法表示为当前列的状态。在转移的时候，我们只知道上一列的右插头，即本列的左插头的情况，而上插头还需要自己记一个标记。

　　那么我们具体分析：

　　1、不存在上插头

　　　　1、同时存在左插头和右插头，不需要修改当前插头，直接把上一列的右插头当做当前列的右插头

　　　　2、只在左插头，即从上一列的某一个连通块转移过来，记录连通块。（左下插头）

　　　　3、只在右插头，即此为一个新的连通块，打上标记，表明这是一个新的连通块。（右下插头）

　　2、存在上插头

　　　　1、同时存在左插头和右插头，一个格子里有三个插头，非法状态

　　　　2、都不存在左插头和右插头，不需要修改当前插头，即从上往下。

　　　　3、存在左插头

　　　　　　1、上插头和左插头同属一个连通块，但不在最终状态（没有右插头）的右下角的格子里出现，非法状态

　　　　　　2、上插头是左下插头，合并连通块，并删除这两个插头（这个合并比较特殊，因为两个都是已知的连通块，具体画图比较清晰）

　　　　　　3、上插头是右下插头，合并连通块，删掉当前插头

　　　　4、不存在左插头

　　　　　　1、上插头是左下插头，合并连通块，删除左下插头

　　　　　　2、上插头是右下插头，合并为新的连通块

　　具体情况还是自己动手画图比较清晰。

　　然后就到了矩乘的部分。首先考虑构造矩阵，g[i][j] = 1表示i状态能推到j状态，因此我们只需要枚举这些状态，一个一个判转移就可以了。

　　初始的情况下，只存在全空的状态和0和N-1有插头的情况，因此答案就是矩阵快速幂后的ans[1][0]，即从初始状态推向终止状态。

程序

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

 using namespace std;

 #define REP(i, a, b) for (int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
 #define DWN(i, a, b) for (int i = (a), i##_end_ = (b); i >= i##_end_; --i)
 #define mset(a, b) memset(a, b, sizeof(a))
 typedef long long LL;
 const int MAXD = , HASH = , STATE = , MOD = ;
 int n, m, code[MAXD], ch[MAXD];
 struct HASHMAP
 {
     int head[HASH], nxt[STATE], state[STATE], siz;
     void clear() { siz = , mset(head, -); }
     int push(int x)
     {
         int pos = x%HASH, i = head[pos];
         for (; i != -; i = nxt[i])
             if (state[i] == x) return i;
         state[siz] = x;
         nxt[siz] = head[pos], head[pos] = siz++;
         return siz-;
     }
 }hm;
 struct Matrix
 {
     int mat[][], D;
     Matrix operator * (const Matrix &AI) const
     {
         Matrix ret; ret.D = D;
         REP(i, , D)
             REP(j, , D)
             {
                 LL sum = ;
                 REP(k, , D) sum += (LL)mat[i][k]*AI.mat[k][j];
                 ret.mat[i][j] = sum%MOD;
             }
         return ret;
     }
 }rc[], A, B;

 void decode(int x)
 {
     DWN(i, n, ) code[i] = x&, x >>= ;
 }

 int encode()
 {
     int cnt = , ret = ;
     mset(ch, -), ch[] = ;
     REP(i, , n)
     {
         if (ch[code[i]] == -) ch[code[i]] = ++cnt;
         ret <<= , ret |= ch[code[i]];
     }
     return ret;
 }

 bool check(int st, int nxt)
 {
     decode(st);
     int up = , k, cnt = ;
     REP(i, , n)
     {
         if (up == )
         {
             if (!code[i] && !(nxt&(<<(i-)))) return false;
             if (code[i] && (nxt&(<<(i-)))) continue ;
             if (code[i]) up = code[i];
             else up = -;
             k = i;
         }
         else
         {
             if (code[i] && (nxt&(<<(i-)))) return false;
             if (!code[i] && !(nxt&(<<(i-)))) continue ;
             if (code[i])
             {
                 if (up == code[i] && !(nxt&(<<(i-))) && (nxt || i != n)) return false;
                 if (up != -)
                 {
                     REP(j, , n) if (code[j] == code[i] && j != i) code[j] = code[k];
                     code[i] = code[k] = ;
                 }
                 else code[k] = code[i], code[i] = ;
             }
             else
             {
                 if (up != -) code[i] = code[k], code[k] = ;
                 else code[i] = code[k] = n+(++cnt);
             }
             up = ;
         }
     }
     if (up) return false;
     return true;
 }

 void init()
 {
     if (rc[n].D != )
     { B = rc[n]; return ; }
     mset(rc[n].mat, );
     hm.clear(), hm.push();
     mset(code, ), code[] = code[n] = , hm.push(encode());
     decode(hm.state[]);
     for (int i = ; i < hm.siz; ++i)
         REP(nxt, , ((<<n)-))
             if (check(hm.state[i], nxt))
             {
                 int j = hm.push(encode());
                 rc[n].mat[i][j] ++;
             }
     rc[n].D = hm.siz-;
     B = rc[n];
 }

 void work()
 {
     mset(A.mat, ); A.D = B.D;
     REP(i, , A.D) A.mat[i][i] = ;
     while (m > )
     {
         if (m&) A = A*B;
         B = B*B, m >>= ;
     }
     if (!A.mat[][]) puts("Impossible");
     else printf("%d\n", A.mat[][]);
 }

 int main()
 {
     REP(i, , ) rc[i].D = ;
     while (~scanf("%d %d", &n, &m))
         init(), work();
     return ;
 }