炮兵阵地(状压dp)

本文探讨了一个基于二进制状态和动态规划的算法,用于解决在特定地形条件下如何最大化炮兵部队部署数量的问题。通过将地图转换为二进制表示,并使用状态转移方程,算法有效地避免了炮兵之间的相互攻击,实现了最优部署。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

描述

传送门:poj-1185

 司令部的将军们打算在NM的网格地图上部署他们的炮兵部队。一个NM的地图由N行M列组成,地图的每一格可能是山地(用”H” 表示),也可能是平原(用”P”表示),如下图。在每一格平原地形上最多可以布置一支炮兵部队(山地上不能够部署炮兵部队);一支炮兵部队在地图上的攻击范围如图中黑色区域所示:

 如果在地图中的灰色所标识的平原上部署一支炮兵部队,则图中的黑色的网格表示它能够攻击到的区域:沿横向左右各两格,沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。
现在,将军们规划如何部署炮兵部队,在防止误伤的前提下(保证任何两支炮兵部队之间不能互相攻击,即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内),在整个地图区域内最多能够摆放多少我军的炮兵部队。

Input

第一行包含两个由空格分割开的正整数,分别表示N和M;
接下来的N行,每一行含有连续的M个字符(‘P’或者’H’),中间没有空格。按顺序表示地图中每一行的数据。N <= 100;M <= 10。

Output

仅一行,包含一个整数K,表示最多能摆放的炮兵部队的数量。

Examples

  • intput

    1
    2
    3
    4
    5
    6
    5 4
    PHPP
    PPHH
    PPPP
    PHPP
    PHHP
  • output

    1
    6

思路

  • 对于每行都用一个二进制数来表示这一行的地图,1表示山地,0表示平原。
  • 用一个$N$位二进制数表示每行放炮兵的状态,1表示放,0表示不放。!(i<<1&i)&&!(i<<2&i) 表示没有两个1相邻,也没有两个1之间只有一个0,那么这个状态合法。
  • $j$状态能放到$i$行的条件是: j&Map[i]==0,即没有山地和炮兵重合。同样的,$i$行,$i-1$行,$i-2$行都不能有炮兵重合,重合了就能互相攻击到。
  • $dp[i][j][k]$: $i$行为状态$j$,$i-1$行为状态$k$时最大ans,状态转移方程就是:

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*
User: Armin
Memory: 3332K Time: 250MS
Language: G++ Result: Accepted
*/
#include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#define rep(i,a,n) for(int i=a;i<n;i++)
#define repd(i,a,n) for(int i=n-1;i>=a;i--)
#define CRL(a,x) memset(a,x,sizeof(a))
const int N=1e2+5;

int dp[N][N][N],n,m,Map[N],Soldier[N]; //dp[i][j][k]:i行为状态j,i-1行为状态k时最大ans
vector<int> ok;
char x;

int Count(int x){int sum=0;while(x){sum++;x-=x&-x;}return sum;}

int main()
{
scanf("%d%d",&n,&m);

rep(i,1,n+1){ //预处理每行状态,每行用一个二进制数表示
getchar();
rep(j,0,m)
Map[i]= Map[i]<<1|getchar()=='H';
}

rep(i,0,1<<m) //预处理出所有合法的状态,放在vector中
if(!(i<<1&i)&&!(i<<2&i)){
Soldier[ok.size()]=Count(i);
ok.push_back(i);
}

rep(i,0,ok.size()) //预处理第一排,枚举所有合法状态
if(!(Map[1]&ok[i])) //可以放到这排
dp[1][i][0]=Soldier[i];

rep(i,2,n+1)
rep(j,0,ok.size()){
if(Map[i]&ok[j]) continue; //和i行有冲突,跳过
rep(k,0,ok.size()){
if(Map[i-1]&ok[k]||ok[j]&ok[k]) continue; //合法状态和i-1行有冲突或者i行状态和i-1行冲突,跳过
rep(l,0,ok.size()){
if(Map[i-2]&ok[l]||ok[l]&ok[k]||ok[l]&ok[j]) continue;//合法状态和i-2行有冲突或 i-2行和i行有冲突 或 i-2行和i-1行有冲突,跳过
dp[i][j][k]=max(dp[i-1][k][l]+Soldier[j] ,dp[i][j][k]); //状态转移
}
}
}

int ans=0;
for(int i=0; i<ok.size(); i++)
for(int j=0; j<ok.size(); j++) //枚举dp[row-1][i][j]
ans=max(ans,dp[n][i][j]);
printf("%d\n",ans);

return 0;
}
<think>我们首先需要理解用户的需求:用户希望了解缩动态规划(DP)的详细原理和应用。根据引用资料,我们可以总结出DP的核心思想、适用条件以及基本实现方法。 ### 缩动态规划(DP)详解 缩动态规划是一种通过将态信息缩(通常使用二进制)来表示动态规划态的方法,适用于态中每个元素只有两种可能(如存在/不存在、选中/未选中)且态规模较小(通常不超过32个元素)的问题。 #### 1. 适用条件 - **态单元简单**:每个态单元只有两种态(例如0/1)。 - **态规模小**:态单元的数量不能太大(通常不超过32,因为一个32位整数可以表示32个态单元)。 - **需要态**:如果不缩,态数量会非常大(例如$2^n$级别),导致无法存储。 #### 2. 基本原理 DP的核心在于用一个整数的二进制位来表示一个集合。例如,一个长度为$n$的二进制数,每一位(0或1)表示某个元素的态(如是否被选中)。这样,一个整数就代表了一个集合。 例如,有5个元素,用5位二进制数表示: - 二进制数`10101`(十进制21)表示第0、2、4个元素被选中(从右向左,最低位为第0位)。 - 这样,我们就可以用一个整数(如21)来代表一个集合。 #### 3. 位运算基础 DP中常用的位运算操作: - **左移(<<)**:`1 << i` 表示将1左移i位,得到第i位为1,其余为0的数。常用于构造某个态。 - **与(&)**:判断某一位是否为1,例如`state & (1<<i)`,如果结果非0,则第i位为1。 - **或(|)**:将某一位设为1,例如`state | (1<<i)`。 - **异或(^)**:将某一位取反,例如`state ^ (1<<i)`。 - **取反(~)**:将每一位取反,例如`~state`(注意整数位数,避免高位干扰)。 #### 4. DP的步骤 DP的解题步骤与普通DP类似,但态表示使用了缩的整数: 1. **定义态**:通常用$dp[i][state]$表示处理到第$i$个阶段(或位置)且当前态为$state$(一个缩的整数)时的最优解(或方案数)。 2. **态转移**:根据问题的规则,从之前的态转移到当前态。通常需要枚举所有可能的前一个态,检查是否满足转移条件。 3. **初始化**:确定初始态(如$dp[0][0]=0$)。 4. **结果提取**:根据最终态(如$dp[n][final\_state]$)得到答案。 #### 5. 经典问题举例:旅行商问题(TSP) 问题描述:有$n$个城市,旅行商从起点0出发,访问每个城市恰好一次后回到起点,求最短路径。 - **态表示**:$dp[state][i]$表示已经访问过的城市集合为$state$,当前位于城市$i$的最短路径长度。 - **态转移**:$dp[state][i] = \min\{ dp[state \setminus \{i\}][j] + dist[j][i] \}$,其中$j$是上一个访问的城市,且$j$在$state$中,$state \setminus \{i\}$表示从集合$state$中移除城市$i$(即态中第$i$位置0)。 - **缩**:$state$是一个$n$位的二进制数,第$k$位为1表示城市$k$已经访问过。 #### 6. 代码示例(TSP问题) ```python def tsp(dist): n = len(dist) # 态总数:2^n total_states = 1 << n # 初始化dp数组:dp[state][i]表示在态state下,当前在i城市的最短路径 dp = [[float('inf')] * n for _ in range(total_states)] # 起点:态1<<0表示只包含0号城市,当前在0城市,路径长度为0 dp[1][0] = 0 # 遍历所有态 for state in range(total_states): # 遍历当前态下的每个城市 for i in range(n): # 如果当前态中不包含i,跳过 if not (state & (1 << i)): continue # 尝试从其他城市j转移到i for j in range(n): # 如果态中包含j,且j不是i,则尝试转移 if i != j and (state & (1 << j)): # 从态state中移除i,得到前一个态prev_state prev_state = state ^ (1 << i) # 更新dp[state][i] dp[state][i] = min(dp[state][i], dp[prev_state][j] + dist[j][i]) # 最终态:所有城市都访问过(全1),并且回到起点0 res = float('inf') for i in range(1, n): # 最后一步从i回到0 res = min(res, dp[total_states-1][i] + dist[i][0]) return res ``` #### 7. 优化与技巧 - **滚动数组**:当态转移只依赖前一阶段时,可优化空间。 - **预处理合法态**:对于某些问题,可以先预处理出所有合法态(如不冲突的态),减少枚举量。 - **剪枝**:在态转移过程中,通过条件判断提前终止无效转移。 #### 8. 应用场景 DP常用于组合优化问题,如: - 旅行商问题(TSP) - 铺砖问题(用1x2砖块铺满网格) - 任务分配问题(每个任务分配给不同的人,每人只能做一个) - 棋盘覆盖问题(如炮兵布阵) ### 总结 缩动态规划通过将缩为整数,有效解决了态空间过大问题。其核心在于位运算的应用和态转移的设计。掌握DP需要熟悉位运算操作,并能够将问题态抽象为二进制表示。 §§相关问题§§ 1. DP中常用的位运算操作有哪些? 2. 如何判断一个态是否包含某个元素? 3. 旅行商问题(TSP)的态转移方程是什么? 4. DP适用于哪些类型的问题? 5. 在缩中,如何表示一个集合的并集、交集和差集?</think>### 缩动态规划(DP)详解 #### 一、核心概念 DP是一种将**集合缩为整数**的动态规划技术。它适用于态中的每个元素只有两种可能(如存在/不存在、选中/未选中),且态规模较小(通常不超过32个元素)的问题。核心思想是将一个集合映射为一个整数的二进制位: - **二进制表示**:用整数的二进制位表示集合元素态 例如:集合 $\{A,C\}$ 在3元素系统中可表示为二进制 `101`(十进制5) - **缩**:将多维缩为单整数 态 $dp[i][S]$ → $dp[S]$,其中 $S$ 是缩后的整数态 #### 二、适用条件(引用[3]) 1. **态单元二元化**:每个态单元仅需两种态(0/1) 2. **态规模小**:态单元数 $n \leq 32$(int存储上限) 3. **态可缩**:态数据能映射为二进制整数 4. **态依赖复杂**:多个元素态共同影响决策(引用[2]) #### 三、位运算基础(关键操作) | 操作 | 符号 | 示例(二进制) | 作用 | |---------------|------|----------------------------|--------------------------| | 判断元素存在 | `&` | `state & (1<<i)` | 检查第 $i$ 位是否为1 | | 添加元素 | `\|` | `state \| (1<<i)` | 将第 $i$ 位置1 | | 删除元素 | `&~` | `state & ~(1<<i)` | 将第 $i$ 位置0 | | 切换元素态 | `^` | `state ^ (1<<i)` | 翻转第 $i$ 位 | | 枚举子集 | `&` | `sub = (sub-1) & state` | 遍历态的所有子集 | #### 四、算法步骤(以经典问题为例) **问题:旅行商问题(TSP)** 求访问所有城市(每个城市仅一次)并返回起点的最短路径 1. **态定义** $dp[state][i]$:当前已访问城市集合为 $state$(缩整数),最后位于城市 $i$ 的最短路径 2. **态转移** $$ dp[state][i] = \min_{j \in state} \{ dp[state \setminus \{i\}][j] + dist[j][i] \} $$ 其中 $state \setminus \{i\}$ 用位运算实现:`state ^ (1<<i)` 3. **初始化** - 起点:$dp[1<<0][0] = 0$(从城市0出发) - 其他态初始化为无穷大 4. **结果提取** $$ \min_{i} \{ dp[full\_state][i] + dist[i][0] \} $$ $full\_state = (1<<n)-1$(所有城市已访问) #### 五、代码实现(TSP问题) ```python def tsp(dist): n = len(dist) total_states = 1 << n # 态总数 2^n dp = [[float('inf')] * n for _ in range(total_states)] # 初始化:从0号城市出发 dp[1 << 0][0] = 0 for state in range(total_states): for i in range(n): if not (state & (1 << i)): # 跳过未访问城市 continue for j in range(n): if state & (1 << j): # j必须在已访问集合中 prev_state = state ^ (1 << i) # 移除当前城市 dp[state][i] = min(dp[state][i], dp[prev_state][j] + dist[j][i]) # 返回最终结果(回到起点0) full_state = (1 << n) - 1 return min(dp[full_state][i] + dist[i][0] for i in range(n)) ``` #### 六、典型应用场景 1. **棋盘覆盖问题** - 如炮兵布阵(引用[4]):每个位置放/不放炮兵 → 二进制位表示 - 约束:同行炮兵间距≥2 → 位运算检查 `state & (state>>1)` 或 `state & (state>>2)` 2. **子集选择问题** - 如背包变种:选择物品组合满足特定条件 - 态:$dp[mask]$ 表示选中物品集合为 $mask$ 的最优解 3. **路径覆盖问题** - 如最小权路径覆盖:用二进制表示已覆盖节点 #### 七、优化技巧 1. **滚动数组**:空间优化(如 $dp[state]$ 只依赖 $dp[state']$) 2. **预处理合法态**:提前计算满足约束的态集合 3. **剪枝**:跳过无效态(如 `state` 中不包含必要元素时) #### 八、复杂度分析 - **时间复杂度**:$O(2^n \times n^2)$(TSP为例) - **空间复杂度**:$O(2^n \times n)$ 当 $n>20$ 时需谨慎使用(引用[3]) > DP通过将高维缩为整数,显著降低了态空间维度,是解决小规模组合优化问题的利器(引用[1][2])。其核心在于**用位运算实现集合操作**,将复杂的集合关系转化为整数运算。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值