POJ 2411 Mondriaan's Dream [经典状态压缩dp]

题意：略。

思路：这一题开始做的时候完全没有思路，便去看了别人的题解。

首先，对于这个题目解法想有一个初步的了解，请看这里：http://www.2cto.com/kf/201208/146894.html

根据这篇讲解，写了一篇扭曲的代码，提交之后TLE。

经过排查分析之后发现，算法的复杂度为O(hw*(2^(2w)))，这个复杂度肯定超了。后来进行了优化，如果两种状态可以匹配，就将它们用邻接表(vector实现)存储起来，这样只需一遍预处理，以后直接读取就可以了。

此外，还有两个地方的优化：

1. 如果h*w为奇数，则结果必为0。（每个砖块的面积为2，无法用整数块铺满）

2. 如果h < w， 将两者数值交换。

后面还有一种dfs+dp的解法，我觉得很精巧，在下面重点分析。这里先贴下上面方法的代码。

 #include<stdio.h>
 #include<iostream>
 #include<vector>
 #include<string.h>
 #include<algorithm>
 using namespace std;
 long long dp[<<][];
 vector<int> ok[<<];
 int h, w;
 bool judge(int up, int down)
 {
     int u[], d[];
     int now = w;
     while (now)
     {
         u[now] = up % ;
         d[now--] = down % ;
         up /= ;
         down /= ;
     }
     for (int i = ; i <= w;)
     {
         if (!d[i])//该行该位为0
         {
             if (!u[i]) return ;//上一行若也为0，则不合法
             i++;
         }
         else if (!u[i])//该行该位为1，且上一行该位为0
             i++;
         else//该行该位为1，且上一行该位也为1
         {
             if (i +  > w || !d[i+] || !u[i+]) return ;
             i += ;
         }
     }
     return ;
 }
 long long getdp()
 {
     memset(dp, , sizeof(dp));
     for (int i = ; i < (<<w); i++)
     {
         ok[i].clear();
         for (int j = ; j < (<<w); j++) if (judge(j, i))
             ok[i].push_back(j);
     }
     for (int i = ; i < ( << w); i++)
         for (int j = ; j < ok[i].size(); j++) if (ok[i][j] == (<<w) - )
         dp[i][] = ;
     for (int i = ; i <= h; i++)
         for (int j = ; j < ( << w); j++)
             for (int k = ; k < ok[j].size(); k++)
                 dp[j][i] += dp[ ok[j][k] ][i-];
     return dp[(<<w)-][h];
 }
 int main()
 {
     while (~scanf("%d%d", &h, &w) && h && w)
     {
         if ((h * w) % )
         {
             printf("0\n");
             continue;
         }
         if (h < w) swap(h, w);
         printf("%lld\n", getdp());
     }
     return ;
 }

===========分割线===============

dfs的方法：

状态压缩的原则与上一种方法是一样的：如果该位为0，则说明该处为一竖放的砖块，且为该砖块的上半部分；其余为1。

核心部分是dfs的方法。首先，dp[state][row]表示铺到第row行，且该行状态为state时的方法总数，这并没有变。每次枚举状态，与上面不同的是，枚举的是上一层的状态。

上一种方法：

for(i = 2; i <= h; i++)//枚举行数

　　for(j = 0; j < (1<<w); j++)//枚举该行的状态

　　　　for(k...)//枚举该行可匹配的上一行状态

dfs版：

for(i = 2; i <= h; i++)//枚举行数

　　for(j = 0; j < (1<<w); j++)//枚举上一行的状态

　　　　if(...) dfs(...)//如果上一行该状态方法数不为0，则dfs遍历该行可行状态

遍历的方法很巧妙：假设所枚举到的上一行状态为s，则将s每一位都取反便是该行的一种可行状态。因为，如果s的某一位是0，说明这是一竖放砖块的上半部分，取反后恰好就是下半部分对应的1；如果s某一位是1，取反后是0，这当然也是可行的。

又由于当s某一位是1时，下一行对应的位可以是0或者1（若是1则必然是横放的，需要连续两位状态都是1）。所以在dfs的过程中需要遍历所有两个0相邻的情况，将他们置为1。当dfs的下标pos到达最后一位（即pos=w）时，说明该状态是可行的，就将该状态的dp值加上上一行状态s的dp值。因此，每次dfs之前都需要暂时存储下上一行状态s的dp值。

这种方法代码既短又巧妙，让人佩服啊。

 #include<stdio.h>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 long long dp[<<][], tem, h, w;
 void dfs(int row,int state,int pos)
 {
     if (pos == w)
     {
         dp[state][row] += tem;
         return;
     }
     dfs(row, state, pos + );
     if (pos <= w -  && !(state & (<<pos)) && !(state & (<<(pos + ))))
         dfs(row, state | <<pos | <<(pos+), pos + );
 }
 int main()
 {
     while (~scanf("%d%d", &h, &w) && h && w)
     {
         if (h * w % )
         {
             printf("0\n");
             continue;
         }
         if (h < w) swap(h, w);
         memset(dp, , sizeof(dp));
         tem = ;
         dfs(, , );
         for (int i = ; i <= h; i++)
             for (int j = ; j < (<<w); j++) if (dp[j][i-])
             {
                 tem = dp[j][i-];
                 dfs(i, ~j & ((<<w) - ), );
             }
         printf("%lld\n", dp[(<<w)-][h]);
     }
     return ;
 }