状态压缩DP（蒙德里安的梦想，最短Hamilton路径）

目录

291. 蒙德里安的梦想

91. 最短Hamilton路径

---

291. 蒙德里安的梦想

求把 N×M 的棋盘分割成若干个 1×2 的长方形，有多少种方案。

例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3 时，共有 3 种方案。

如下图所示：

输入格式

输入包含多组测试用例。

每组测试用例占一行，包含两个整数 N 和 M。

当输入用例 N=0，M=0 时，表示输入终止，且该用例无需处理。

输出格式

每个测试用例输出一个结果，每个结果占一行。

数据范围

1 ≤ N , M ≤ 11

输入样例：

1 2
1 3
1 4
2 2
2 3
2 4
2 11
4 11
0 0

输出样例：

1
0
1
2
3
5
144
51205

总体思路：

（1）核心：先放横着的，再放竖着的；如果横着的方块固定，竖着的方块自然也固定，得到总方案数为，只放横着的方块的合法方案数

状态表示的前提：表示第 i 列的状态可以用二进制表示，0表示前一列未伸出到该列，1表示伸出到了该列，如 第 2 列的状态为 010 ，表示为 第 1 列的第一行未伸到第二列，第 1 列的第二行伸出到了第二列，第一列的第三行未伸到第二列，如下图表示 010

进一步解释：

前一列未伸出到该列，含义为 横向的两格方块占据了第 i-2 列 和 i-1列

前一列伸出到该列，含义为 横向的两格方块占据了第 i-1 列 和 i列

（2）如何判断是否合法：不重叠，不连续奇数0

对重叠的不合法状态的解释：如果第 i-2 列 和 第 i-1 列同时为 1 ，意味着 i-1 列被两个横向方格占据，为不合法的情况

对不连续奇数个零的的解释：竖着的方块为两格方块，判断每一列中放完横着的方块后，0如果连续的个数为奇数个，就无法放竖方块，为不合法方案，（合法方案不能有空格子，必须都放方块）

闫氏DP分析法：

 解释两个条件：

（1）：第 i-1 列伸出的不能与第 i 列存在的重叠

（2）：空格长度必须是偶数，竖方块高度为2

时间复杂度分析：

共有 11 列，第 i-1 行有 2^11 种状态，第 i 列有2^11种状态，11*2^11*2^11 = 4000 0000 时间复杂度较危险，要预处理出来（1）连续偶数的状态（2）对于 i - 1的每种状态的匹配的状态的个数，如此可降低时间复杂度

最后要输出的结果为：f[m][0] 在前 m-1 列摆好，且第m列伸出为0的状态的方案，我们是从0 开始的所以，前m-1正好符合我们的需求

代码如下： 

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long LL;

const int N = 12, M = 1 << N;

int n, m;
LL f[N][M];
vector<int> state[M];
bool st[M];

int main()
{
    while(scanf("%d%d", &n, &m), n || m)
    {
        // 预处理每种状态的正确性（偶数连续）
        for(int i = 0; i < 1 << n; i ++ )
        {
            int cnt = 0;
            bool is_valid = true;
            for(int j = 0; j < n; j ++ )
            {
                if((i >> j) & 1)
                {
                    if(cnt & 1) 
                    {
                        is_valid = false;
                        break;
                    }
                    cnt = 0;
                }
                else cnt ++;
            }
            
            if(cnt & 1) is_valid = false;
            st[i] = is_valid;
        }
        
        //判断 每种状态可以匹配的下一种状态
        //（i-1行的所有状态可以匹配的第i行的状态）
        for(int i = 0; i < 1 << n; i ++ )
        {
            state[i].clear();
            for(int j = 0; j < 1 << n; j ++ )
            {
                if((i & j) == 0 && st[i|j]) state[i].push_back(j);
            }
        }
        
        // dp
        
        memset(f, 0, sizeof f);
        
        f[0][0] = 1;
        
        for(int i = 1; i <= m; i ++ )
        {
            for(int j = 0; j < 1 << n; j ++ )
            {
                for(auto k : state[j])
                {
                    f[i][j] += f[i-1][k];
                }
            }
        }
        
        cout << f[m][0] << endl;
        
    }
    
    return 0;
}

91. 最短Hamilton路径

给定一张 n 个点的带权无向图，点从 0∼n−1 标号，求起点 0 到终点 n−1 的最短 Hamilton 路径。

Hamilton 路径的定义是从 0 到 n−1 不重不漏地经过每个点恰好一次。

输入格式

第一行输入整数 n。

接下来 n 行每行 n 个整数，其中第 i 行第 j 个整数表示点 i 到 j 的距离（记为 a[i,j]）。

对于任意的 x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]≥a[x,z]。

输出格式

输出一个整数，表示最短 Hamilton 路径的长度。

数据范围

1≤n≤20
0≤a[i,j]≤10^7

输入样例：

5
0 2 4 5 1
2 0 6 5 3
4 6 0 8 3
5 5 8 0 5
1 3 3 5 0

输出样例：

18

思路： 闫氏DP分析法

 状态压缩DP的关键：将经过的点压缩为一个二进制整数 i （仍然以十进制表示），例如 10110 表示经过了 2，3，5点  

状态计算思路：设 k 为 j 的前一个点，枚举 i 中所有经过 k 的点的路径，挑选最短的路径+w[k][j]

初始化：f[1][0] = 0（表示[0,0]状态，从0到0长度0），f 为 0x3f3f3f3f 

 代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 20, M = 1 << N;

int n, m;
int w[N][N];
int f[M][N];

int main()
{
    cin >> n;
    
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            cin >> w[i][j];
            
    memset(f, 0x3f, sizeof f);
    f[1][0] = 0;
    
    for (int i = 0; i < 1 << n; i ++ )
        for(int j = 0; j < n; j ++ )
            if(i >> j & 1) // 判断每一点是否经过，若经过此点，则枚举之前的点更新此点
                for (int k = 0; k < n; k ++ ) 
                    if( i - (1 << j) >> k & 1) // 枚举此路径除了 j 的其他点
                        // 更新
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
    
    // 最终的状态为 经过所有点，到达 n-1 点，即、f[n位1][n-1]                  
    cout << f[ (1 << n) - 1][n-1] << endl;
    
    return 0;
}