状态压缩DP经典问题： ACwing292.炮兵阵地

状态压缩DP

状态表示

dp[i][j][k]表示第i 行摆放炮兵部队，第i - 1行的摆放状态为j, 第i行状态为k的最大值。第i行和第i - 1行的状态和第i - 1行的状态j和第i - 2行的状态u有关，dp[i][j][k]由dp[i - 1][j][k] + cnt[st[k]]转移得来，cnt[st[k]]表示当前k状态的炮兵数量，即：
$$\mathrm{d}\mathrm{p}[\mathrm{i}][\mathrm{j}][\mathrm{k}]=\max (\mathrm{d}\mathrm{p}[\mathrm{i}][\mathrm{j}][\mathrm{k}],\mathrm{d}\mathrm{p}[\mathrm{i}-1][\mathrm{u}][\mathrm{j}]+\mathrm{c}\mathrm{n}\mathrm{t}[\mathrm{s}\mathrm{t}[\mathrm{k}]])$$

状态计算

保存状态：

1. 先进行检查，维护相邻i 和 i - 1，i - 2列的状态合法性，即 ：两列不能同时为1， 保存状态
2. 计算当前状态下的摆放的炮兵数，即保存当前状态下1的个数

保证集合的合法性：

1. 在炮兵攻击的范围内的两列不能同时为1，即 i 和i - 1, i 和 i - 2行不能存在冲突，即不能让三行的状态为1， 或任意两行的状态同时为1
2. 某个位置是山地位置，状态表示为1,枚举到当前所在的合法状态时，保证当前状态不能为1 即 ：g[i] & st[k] | g[i - 1] & st[j] 不能为1

时间复杂度

最坏时间复杂度是$$O\left(n\ast s^2\ast k\right)$$ n表示行数，s表示合法状态数量，k表示合法状态的转移数量， 由于状态很少，因此代码可以通过。需要用到滚动数组，不然会爆内存，滚动数组的方法见代码

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

const int N = 11, M = (1 << 10);
const int L = 110;

int n, m;

int g[L];
int cnt[M];
int dp[2][M][M];
vector<int> st;

//列的合法性
bool check(int s)
{
    for (int i = 0; i < m; i++) {         
        if ((s >> i & 1) && ((s >> (i + 1) & 1) || (s >> (i + 2) & 1))) {
            return false;
        }
    }
    return true;
}

//统计当前状态下的炮兵个数
int count(int x)
{
    int res = 0;
    while (x) {
        res++;
        x &= (x - 1);
    }
    return res;
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < m; j++) {
            char t;
            cin >> t;
            if (t == 'H') {     //山地状态设置为1,方便用& 运算
                g[i] += (1 << j);
            }
        }
    }
    
    for (int i = 0; i < (1 << m); i++) {
        if (check(i)) {        //保存合法状态
            cnt[i] = count(i);
            st.push_back(i);
        }
    }
    
    for (int i = 1; i <= n + 2; i++) {
        for (int j = 0; j < st.size(); j++) {     //i - 1的状态
            for (int k = 0; k < st.size(); k++) {    //i的状态
                for (int u = 0; u < st.size(); u++) {    //i - 2的状态
                    int a = st[u], b = st[j], c = st[k];
                    if ((g[i] & c) | (g[i - 1] & b)) continue;   
                    if ((a & b) | (a & c) | (b & c)) continue;
                    dp[i & 1][j][k] = max(dp[i & 1][j][k], dp[i - 1 & 1][u][j] + cnt[c]);  //不用滚动数组超内存
                }
            }
        }
    }
    
    cout << dp[n + 2 & 1][0][0] << endl;
    
    return 0;
}