计蒜客 灌溉机器人（状压DP）

灌溉机器人

#include 
#include 
using namespace std;

const int MAX_N = 100;
const int MAX_M = 10;
int state[MAX_N + 1];//i行状态
//int dp[MAX_N + 1][1 << MAX_M][1 << MAX_M];//i行状态为j i-1行状态为k时包含的最多1的个数
int dp[2][1 << MAX_M][1 << MAX_M];//i行状态为j i-1行状态为k时包含的最多1的个数

bool not_intersect(int now, int prev) {
    return (now & prev) == 0;
}

bool fit(int now, int flag) {
    return (now | flag) == flag;
}
bool ok(int x) {
    // 行内自己不相交，返回true
    return ( (x & (x / 2)) == 0 ) && ( (x & (x / 4)) == 0 );
}

int calc(int now) {
    int s = 0;  // 统计 now 的二进制形式中有多少个 1
    while (now) {
        s += (now & 1);  // 判断 now 二进制的最后一位是否为 1，如果是则累加
        now >>= 1;  // now 右移一位
    }
    return s;
}

int main() {
    int n, m;
    cin >> n >> m;
    // 初始化所有数组
    memset(state, 0, sizeof(state));
    memset(dp, 0, sizeof(dp));

    char c;
    for (int i = 1; i <= n; ++i) {
        for (int j = 0; j < m; ++j) {
            int flag;
            cin >> c;
            if(c == 'P') {
                flag = 1;
            } else {
                flag = 0;
            }
            state[i] |= (1 << j) * flag;  // 将 (i,j) 格子的状态放入 state[i] 中，state[i] 表示第 i 行的可选格子组成的集合
        }
    }

    //处理第1行边界
    for(int j = 0; j < (1 << m); ++j) {
        if (!ok(j) || !fit(j, state[1])) {  // 如果第1行状态不合法则不执行后面的枚举
                continue;
        }

        int cnt = calc(j);
        dp[1%2][j][0] = cnt;

    }

    //处理第2行边界
    for(int j = 0; j < (1 << m); ++j) {
        if (!ok(j) || !fit(j, state[2])) {  // 如果第2行状态不合法则不执行后面的枚举
                continue;
        }

        int cnt = calc(j);
        for (int k = 0; k < (1 << m); ++k) {
            if (ok(k) && fit(k, state[1]) && not_intersect(j, k)) {  // 第1行合法且第2行 第1行不冲突
                dp[2%2][j][k]= dp[1%2][k][0] + cnt;  // 更新当前行、当前状态的最优解
            }
        }
    }

    //正常处理
    for (int i = 3; i <= n; ++i) {
        for (int j = 0; j < (1 << m); ++j) {  // 枚举当前行的状态
            if (!ok(j) || !fit(j, state[i])) {  // 如果当前行状态不合法则不执行后面的枚举
                continue;
            }

            int cnt = calc(j);  // 统计当前行一共选了多少个格子

            for (int k = 0; k < (1 << m); ++k) {//上行状态为k
                if (!ok(k) || !fit(k, state[i-1])) {  // 如果上行状态不合法则不执行后面的枚举
                    continue;
                }

                for(int l = 0; l < (1 << m); ++l) {//上上行状态为l
                    if (!ok(l) || !fit(l, state[i-2])) {  // 如果上上行状态不合法则不执行后面的枚举
                        continue;
                    }

                    if(not_intersect(j, k) && not_intersect(k, l) && not_intersect(j, l)) {
                        dp[i%2][j][k]= max(dp[i%2][j][k], dp[(i - 1)%2][k][l] + cnt);  // 更新当前行、当前状态的最优解
                    }
                }

            }
        }
    }

    int ans = 0;  // 保存最终答案
    for (int i = 0; i < (1 << m); ++i) {
            for(int j = 0; j < (1 << m); ++j)
                ans = max(ans, dp[n%2][i][j]);  // 枚举所有状态，更新最大值
    }
    cout << ans << endl;
    return 0;
}