P2704 [NOI2001] 炮兵阵地

1. [P2704 NOI2001] 炮兵阵地

问题描述

题目要求在一个 N x M 的地图上选择尽可能多的兵，兵可以站在标记为 P 的位置上，但不能放在相邻的位置（包括横向和纵向相邻）。目标是最大化选择的兵数。

状态定义

我们可以通过动态规划来解决这个问题，状态可以定义如下：

1. 状态表示:
   设 dp[i][j][k] 表示在第 i 行选择了状态 j、第 i-1 行选择了状态 k 时，能得到的最大士兵数。

2. 状态空间:
   每一行有 M 个位置，每个位置上有两种状态（放置或者不放置士兵），所以一行共有 (2^M) 种可能的放置状态。

3. 状态合法性:

   • j、k 不能在同一行的相邻两个位置上都有士兵（即需要确保 j 和 k 对应的状态中的“1”不相邻）。
   • j、k 不能在相邻两行的相邻位置上都有士兵。

状态转移方程

在第 i 行，状态 j 可以从第 i-1 行的状态 k 转移过来。状态转移方程为：

$$dp[i][j][k]=\max (dp[i-1][r][k])+\text{count}(i,j)$$
其中 r 是与 j、k 都不冲突的上一行状态。count(i, j) 计算第 i 行，状态 j 下选出的士兵总数。

边界条件

• 在初始状态（即 i = 0）下，dp[0][j][k] 等于 count(0, j)，因为此时只有一行，不存在转移。

解题思路

1. 预处理状态:
   我们首先要生成所有满足条件的合法状态。对于每一个状态 sta[j]，我们要求它不能有相邻的“1”。

2. 计算 DP 表:
   对于每一行的每一个状态 j 和 k，我们在上一步合法的 r 中找到最优解，并加上当前行的 count(i, j)。

3. 结果输出:
   遍历所有行、所有状态的结果，输出全局的最大值 ans。

代码分析

#include <bits/stdc++.h>
using namespace std;

int N, M;
const int Nr = 1024; // 2^10 - M最大为10，所以最多1024种状态
int maps[105][15];   // 地图大小不超过 200x15
int sta[Nr];
int rec = 0;
int dp[2][Nr][Nr];

int count(int i, int x)
{
   int sum = 0;
   for (int j = 0; j < M; j++)
   {
      if (x & (1 << j))
         sum += maps[i][j];
   }
   return sum;
}

void init(int n)
{
   for (int i = 0; i < n; i++)
   {
      if ((i & (i >> 2)) == 0 && ((i & (i >> 1)) == 0) && ((i & (i << 1)) == 0) && ((i & (i << 2)) == 0))
         sta[rec++] = i;
   }
}

int main()
{
   cin >> N >> M;
   char ch;
   for (int i = 0; i < N; i++)
   {
      for (int j = 0; j < M; j++)
      {
         cin >> ch;
         maps[i][j] = (ch == 'P') ? 1 : 0;
      }
   }
   init(1 << M);

   int ans = 0;
   for (int i = 0; i < N; i++)
   {
      for (int j = 0; j < rec; j++)
      {
         for (int k = 0; k < rec; k++)
         {
            dp[i % 2][j][k] = 0;
            if (i == 0)
            {
               dp[i % 2][j][k] = count(i, sta[j]);
               ans = max(ans, dp[i % 2][j][k]);
               continue;
            }
            if (sta[j] & sta[k])
               continue;
            int tmp = 0;
            for (int r = 0; r < rec; r++)
            {
               if (sta[r] & sta[j])
                  continue;
               if (sta[r] & sta[k])
                  continue;
               tmp = max(tmp, dp[(i - 1) % 2][k][r]);
            }
            dp[i % 2][j][k] = tmp + count(i, sta[j]);
            ans = max(ans, dp[i % 2][j][k]);
         }
      }
   }
   cout << ans << endl;
   return 0;
}