第五章 动态规划(5)：状态压缩模型

1、棋盘式DP / 基于连通性的DP

1.1、蒙德里安的梦想（基本模型）（连通性：1X2矩阵）

ACWing 291

算法思想：

我们先考虑横向摆放条件下，即仅摆放2x1的方块的时候，总的方案数等于只放横着的小方块的合法方案数。因为所有横放确定了，那么竖放方案是唯一的。

如何判断方案是否合法？所有剩余未知能否填充满竖直着的小方块。可以按列来看，每一列内部所有连续的空着的小方块需要是偶数个。

f[i, j]：所有摆到第i列，上一列伸出来的行的状态是j（j是一个二进制数，j ∈ (0, 2^(列数))）的情况下，即上一列有哪些行伸进第二列的情况下，总共的方案数。

对于状态转移，我们考虑第i-1个状态，有

要使状态i-1能转换为i，必须满足条件：

• 条件一：第i-1个状态和第i个状态不能冲突，即(j & k) == 0；
• 条件二：第i-1列中纵向的连续格子个数必须是偶数，即j | k不能存在奇数个0。因为我们这里考虑的是横向1x2的格子，当横向格子填完了之后，就要使用纵向2x1的格子来填，它只能填入连续个数为偶数的纵向格子。

所以状态转移方程表示为：f[i, j] += f[i-1, j]

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

using namespace std;

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

int n, m;
long long f[N][M]; // 第一维表示列，第二维表示所有可能的状态
bool st[M]; //存储每种状态是否有奇数个连续的0，如果奇数个0是无效状态，如果是偶数个零置为true

int main()
{
   
    while (cin >> n >> m, n || m) // 读入n和m，且n 或 m 不等于0
    {
   
        memset(f, 0, sizeof f);
        
        // 预处理掉所有状态存在奇数个0的情况
        for (int i = 0; i < 1 << n; i ++ )
        {
   
            st[i] = true;
            
            int cnt = 0; // 表示当前这一段连续0的个数   
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1) // 如果第j位为1，这一段遍历完
                {
   
                    if (cnt & 1) // 判断这一段中0的个数cnt是否为奇数
                        st[i] = false;
                    cnt = 0; // 这一段结束
                }
                else 
                    cnt ++ ;
            
            if (cnt & 1) // 判断你最后一段0的个数cnt是否是奇数
                st[i] = false;
        }
        
        f[0][0] = 1; // 一个都不摆，f[0][j]、f[i][0] 都不可能
        for (int i = 1; i <= m; i ++ ) // 枚举所有列，列数的下标是从0开始的，注意这里的 i
            for (int j = 0; j < 1 << n; j ++ ) // 枚举所有状态
                for (int k = 0; k < 1 << n; k ++ ) // 枚举第i-1列所有状态
                    if ((j & k) == 0 && st[j | k])
                        f[i][j] += f[i - 1][k];
        
        /* 每一列的下标都是从 0 开始的 */
        cout << f[m][0] << endl; // 合法状态是第 m-1 列没有伸出来到第 m 列的行
    }
    
    return 0;
}

1.2、小国王（连通性：井字形）

ACwing 1064

由题分析，因为第i行的状态只和第i-1行有关系，与1 ~ i-2行无关。

集合

f[i,j,s]：所有只摆在前i行已经放完，并且放完了j个国王，最后第i行摆放的状态是s的所有的方案数。

这里的s是一个二进制数，如果有n列，那么s是一个n位的二进制数

集合划分

根据第i-1层状态来划分，该层共有2^n中情况，要使第i-1行转移成第i行的s状态，第i-1行的状态必须满足：

• 第i-1行内部不能有两个1相邻
• 第i-1行和第i行之间也不能相互攻击到

对于第二个性质：假设第i-1行状态的值为a，第i行的值为b，那么只要满足

1. (a & b) == 0 // 同一列不能相互攻击
2. (a | b) 的结果不能存在两个相邻的 1 // 斜对角线上不能相互攻击

状态计算

1. 若两个性质都满足，由上图，那么f[i,j,b]表示已经摆完了前i排，使用了j个国王，并且第i排的状态是b，第i-1排的状态是a的所有方案。
2. 如果去掉最后一排，那么f[i-1,j-count(b),a]表示已经摆完了前i-1排，使用了j-count(b)个国王，并且第i-1排的状态是a的所有方案数。

所以计算1的方案数可以有计算2的方案数得出。

#include <iostream>
#include <vector>

using namespace std;

typedef long long LL;

const int N = 12, M = 1 << 10, K = 110; // k是国王数量，这里N开到12是为了方便最后输出

int n, m; // n表示个数，m表示国王数量
vector<int> state; // 表示所有合法的状态
int cnt[M]; // cnt存储每个状态中1的个数
vector<int> head[M]; // 每个状态可以转移到的其它状态
LL f[N][K][M];

// 判断state中是否存在两个相邻的1
bool check(int state) {
   
    for (int i = 0; i < n; i++)
        if ((state >> i & 1) && (state >> (i + 1) & 1))
            return false;
    return true;
}

// 返回state中1的个数
int count(int state) {
   
    int res = 0;
    for (int i = 0; i < n; i++)
        res += state >> i & 1;
    return res;
}

int main() {
   
    cin >> n >> m;

    for (int i = 0; i < 1 << n; i++)
        if (check(i)) // 检查当前状态中是否存在两个连续的1
        {
   
            state.push_back(i);
            cnt[i] = count(i);
        }


    // 建立不同状态之间的转移关系
    for (int i = 0; i < state.size(); i++)
        for (int j = 0; j < state.size(); j++) {
   
            int a = state[i], b = state[j]; // a代表第一个状态，b代表第二个状态
            if ((a & b) == 0 && check(a | b)) // 判断是否能转移的两个条件是否满足
                head[i].push_back(j); // 将b添加到a可以转移状态的集合中去
        }

    // dp
    f[0][0][0] = 1;
    for (int i = 1; i <= n + 1; i++) // 直接摆到n+1，方便最后输出，即第n+1行一个都不摆
        for (int j = 0; j <= m; j++) // 国王的数量
            for (int a = 0; a < state.size(); a++) // 枚举所有状态
                for (int b: head[a]) // 枚举a所有能到的状态b
                {
   
                    int c = cnt[state[a]]; // a中1的个数
                    if (j >= c) // 每一行国王数量要小于总的国王数量上限
                        f[i][j][a] += f[i - 1][j - c][b];
                }

    cout << f[n + 1][m][0] << endl; // 第 n+1 行一个都不摆

    return 0;
}

1.3、玉米田（连通性：十字型）

ACwing 327

由题分析，因为第i行的状态只和第i-1行有关系，与1 ~ i-2行无关。

集合

f[i, s]：所有摆放了前i行，且第i行状态是s的所有摆放方案的集合

集合划分

根据第i-1层状态来划分，该层共有2^n中情况，要使第i-1行转移成第i行的s状态，第i-1行的状态必须满足：

• 第i-1行、第i行内部都不能有两个1相邻
• 第i-1行和第i行之间同一列不能同时为1，即(a & b) == 0
  

状态计算

• 已经摆完前i行，且第i行状态是a，第i-1行的状态是b的所有摆放方案
• 去掉最后一行a，则就变成
• 已经摆完前i-1行，且第i-1行的状态是b的所有摆放方案：f[i-1,b]

#include <iostream>
#include <vector>

using namespace std;

const int N = 14, M = 1 << 12, mod = 1e8;

int n, m;
int g[N];
vector<int> state;
vector<int> head[M];
int f[N][M];

bool check(int state) // 检查是否存在相邻的1
{
   
    for (int i = 0; i + 1 < m; i ++ )
        if ((state >> i & 1) && (state >> (i + 1) & 1))
            return false;
    return true;
}

int main() {
   
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j < m; j ++ )
        {
   
            int t;
            cin >> t;
            g[i] += !t * (1 << j); // t=0的时候，表示该位置不能选择，将其置为1，表示不能选择
        }
    
    // 预处理所有合法状态
    for (int i = 0; i < 1 << m; i ++ )
        if (check(i))
            state.push_back(i);
    
    // 不同合法状态之间的转移关系
    for (int i = 0; i < state.size(); i ++ )
        for (int j = 0; j < state.size(); j ++ )
        {
   
            int a = state[i], b = state[j];
            if ((a & b) == 0) // 判断条件
                head[i].push_back(j);
        }           
    
    // dp
    f[0][0] = 1;
    for (int i = 1; i <= n + 1; i ++ )
        for (int j =