状态压缩dp

蒙德里安的梦想：

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

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

如下图所示：

输入格式

输入包含多组测试用例。

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

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

输出格式

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

数据范围

1≤N,M≤111≤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

 一个重要思想 ： 用二进制数表示状态

 因为它的填充元素只有两个， 故， 我们只需要考虑一个元素的状态数量。

状态表示 : f [ i ] [ j ] 表示 第 i - 1 列横着的小方块的头部 的一种状态。

状态计算： f [ i ] [ j ] = 可以与它匹配的所有 f [ i - 1 ] [ j ] 的和。

可以预先处理 不符合规则的二进制状态（有奇数 0 ）

以及只把符合规则的二进制状态存起来 ， 只用这些数据dp

代码： 

#include<iostream>
#include<cstring>


using namespace std;

long long f[N][N];

bool st[M];

vector<int> state[M];

int m, n;

int main()
{
    while(cin >> n >> m, m || n)
    {
        for(int i = 0; i < 1 << n; i++)  预处理 1.
        {
            int cnt = 0;

            bool isvalid = true;

            for(int j = 0; j < n; j ++)
            {
                if(i >> j & 1) 
                {
                    if(cnt & 1) 
                    {
                        isvalid = false;
                        break;
                    }
                    cnt = 0;
                }
                else cnt ++ ;
            }
            if(cnt & 1) isvalid = false;
            st[i] = isvalid;
        }
    }

    for(int j = 0; j< 1 << n; j ++)  预处理 2.
    {
        state[j].clear();
        // k 表示的是上一行的二进制状态。
        for(int k = 0; k < 1 << n; k ++)  
        {
            if((j & k) == 0 && st[j | k]) 
             //  分别判断的是是否与上一列伸出来的方块冲突，  以及新的填充状态是否有奇数 0 .
            state[j].push_back(k);
        }
    }

    // dp 阶段。

    memset(f, 0, sizeof f);
    //  要明确他的状态表示 ： i - 1 行摆入的方块（头部）。
    f[0][0] = 1; // 表示第 - 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;
}

最短Hamilton路径：

题目描述
给定一张 nn 个点的带权无向图，点从 0∼n−10∼n−1 标号，求起点 00 到终点 n−1n−1 的最短 HamiltonHamilton 路径。 HamiltonHamilton 路径的定义是从 00 到 n−1n−1 不重不漏地经过每个点恰好一次。

输入格式
第一行输入整数 nn。

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

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

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

数据范围
1≤n≤201≤n≤20
0≤a[i,j]≤1070≤a[i,j]≤107
输入样例：
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

 同样是用二进制数来表示状态，

状态表示：f [ j, i ]   :  j 是一个二进制数，表示当前状态。 i 表示当前连了几个数。属性： 最短距离。

状态计算： f [ j , i ]  = min( f [ i ] [ j ] ,  f [ j - ( 1 << i )] [ k ] + w [ k ] [ i ]  );(遍历除当前所有的点，作为倒数第二个点，来求得最短距离。）

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

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

int f[M][N], w[N][N]; // w 是有权图。

int main()
{
    int n;
    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 = 1; i < 1 << n; i ++)
    for(int j = 0; j < n; j ++)
    if(i >> j & 1) 
    for(int k = 0; k < n; k ++)
    if(i >> k & 1) 
    f[i][j] = min(f[i - (1 << j)][k] + w[k][j], f[i][j]);

    cout << f[(1 << n) - 1][n - 1] << endl;
}