状态压缩DP（c++）

所谓的状态压缩DP，就是用二进制数保存状态。为什么不直接用数组记录呢？因为用一个二进制数记录方便作位运算。

AcWing 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. 本题等价于找到所有横放 1 X 2 小方格的方案数，因为所有横放确定了，那么竖放方案是唯一的。

2. 用f[i][j]记录第i列第j个状态。j状态位等于1表示上一列有横放格子，本列有格子捅出来。转移方程很简单，本列的每一个状态都由上列所有“合法”状态转移过来f[i][j] += f[i - 1][k]

3. 两个转移条件： i 列和 i - 1列同一行不同时捅出来； 本列捅出来的状态j和上列捅出来的状态k求或，得到上列是否为奇数空行状态，奇数空行不转移。

4. 初始化条件f[0][0] = 1，第0列只能是状态0，无任何格子捅出来。返回f[m][0]。第m + 1列不能有东西捅出来。

1
0
1
2
3
5
144
51205

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

using namespace std;

const int N = 12, M = 1 << N;//M的每一位二进制位储存一种状态

int n, m;
long long f[N][M];//f[i][j]表示摆放第i列，i列向后伸出来横着的方格状态为j的方案数，j为一个二进制数，用01表示是否戳出来
bool st[M];//储存每一列上合法的摆放状态

int main()
{
    while (cin >> n >> m, n || m)//枚举每一列的占位状态里哪些是合法的
    {
        for (int i = 0; i < 1 << n; i ++ )//一共n行，枚举n位不同的状态
        {
            int cnt = 0;//用来记录连续的0的个数
            st[i] = true;//记录这个状态被枚举过且可行
            for (int j = 0; j < n; j ++ )//从低位到高位枚举它的每一位
                if (i >> j & 1)//如果为1
                {
                    if (cnt & 1) st[i] = false;// cnt 为当前已经存在多少个连续的0
                    cnt = 0;//清空计数器
                }
                else cnt ++ ;//如果不为1，计数器+1
            if (cnt & 1) st[i] = false;// 扫完后要判断一下最后一段有多少个连续的0
        }

        memset(f, 0, sizeof f);//一定要记得初始化成0，对于每个新的输入要重新计算f[N][M]
        f[0][0] = 1;
        for (int i = 1; i <= m; i ++ )//对于每一列
            for (int j = 0; j < 1 << n; j ++ )//枚举j的状态
                for (int k = 0; k < 1 << n; k ++ )//再枚举前一行的伸出状态k
                    if ((j & k) == 0 && st[j | k]) // j & k == 0 表示 i 列和 i - 1列同一行不同时捅出来
                    // st[j | k] == 1 表示 在 i 列状态 j， i - 1 列状态 k 的情况下是合法的.
                        f[i][j] += f[i - 1][k];

        cout << f[m][0] << endl;//求的是第m行排满，并且第m行不向外伸出块的情况
    }
    return 0;
}

AcWing 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⁷
输入样例：

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

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

using namespace std;

const int N = 20, M = 1 << N;// 一共最多有 20 个 1 种状态

int n;
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 初始化为正无穷会更好处理一些
    f[1][0] = 0;// 因为题目要求从点 0 出发，所以这里要将 经过点集为 1，当前到达第 0 个点 的最短路径初始化为 0

    for (int i = 0; i < 1 << n; i ++ )// 从 0 到 111...11 枚举所有i
        for (int j = 0; j < n; j ++ )// 枚举所有 i到达的点
            if (i >> j & 1)// 如果当前点集包含点 j，那么进行状态转移
                for (int k = 0; k < n; k ++ )// 枚举所有 k
                    if (i >> k & 1)// 如果从当前状态经过点集 i 中，去掉点 j 后，i 仍然包含点 k，那么才能从点 k 转移到点 j。
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);//选择最小值，也就是判断，k点到j点最优，还是以前的方案最优

    cout << f[(1 << n) - 1][n - 1];//输出最后的最优值

    return 0;
}