DP(状压专题九)

题意 : 有 k ≤ 16 k \leq16 k16枚硬币,每枚价值 a [ i ] ≤ 1 e 8 a[i] \leq 1e8 a[i]1e8,有 m ≤ 1 e 6 m\leq1e6 m1e6件物品, 每件物品 c o s t [ i ] ≤ 1 e 4 cost[i]\leq1e4 cost[i]1e4, 而且必须顺序买, 问在不找零的情况下自己最多能剩多少钱

>> face <<

Strategy:状压DP, i是一个表示二进制的十进制数,'1’是当前位置的硬币被选了

状态: dp[i]->状态为i所能顺序买最远物品的下标

目标: 所有dp[i] = m 的i里对应的0位(没有选的硬币),的价值的最大值

边界: dp[0] = 0;

合法判断: 无

转移方程:

d p [ i ∣ 1 &lt; &lt; j − 1 ] = m a x ( d p [ i ∣ 1 &lt; &lt; j − 1 ] , u p p e r b o u n d ( s u m , s u m + m , s u m [ d p [ i ] ] + a [ j ] ) − s u m ) dp[i | 1 &lt;&lt; j - 1] = max(dp[i | 1 &lt;&lt; j - 1], upperbound(sum, sum + m, sum[dp[i]] + a[j]) - sum) dp[i1<<j1]=max(dp[i1<<j1],upperbound(sum,sum+m,sum[dp[i]]+a[j])sum)

attention: 转移方程一定要缜密

双倍经验: 注意转移方程

#include <bits/stdc++.h>
#include <bits/extc++.h>
#define oo 0x3f3f3f3f
#define ll long long
#define db double
#define all(a) a.begin(), a.end()
#define met(a, b) memset(a, b, sizeof(a))
#define what_is(x) cout << #x << " is " << x << endl
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define _rev(i, a, b) for (int i = (a); i >= (b); --i)
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define lowbit(x) x &(-x)
#define bin(x) cout << #x << " is " << bitset<sizeof(int) * 2>(x) << endl
#define pi acos(-1.0)
using namespace std;
using namespace __gnu_pbds;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
ll sum[maxn], a[17];
ll n, m, money[maxn];
int dp[1 << 16];
const db eps = 1e-8;

int main()
{
	ios::sync_with_stdio(0);
	cin >> n >> m;
	_rep(i, 1, n){
		cin >> a[i];
	}
	_rep(i, 1, m){
		ll x;
		cin >> x;
		sum[i] = sum[i - 1] + x;
	}

	_rep(i, 0, (1 << n) - 1){
		_rep(j, 1, n){
			if(i >> j - 1 & 1)
				continue;
			
			dp[ i | 1 << j - 1] = max(dp[i | 1 << j - 1], (int)(upper_bound(sum + 1, sum + 1 + m, sum[dp[i]] + a[j]) - sum - 1));
		}
	}	
	
	
	ll ans = -1;
	_rep(i, 0, (1 << n) - 1){
		if(dp[i] == m){
			ll left = 0;
			_rep(j, 1, n){
				if(!(i >> j - 1 & 1)){
					left += a[j];
				}
			}
			ans = max(ans, left);
		}
	}
	cout << ans << endl;
}


第一次回顾, 重点:转移方程的转移

#include <bits/stdc++.h>
#include <bits/extc++.h>
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define _rev(i, a, b) for (int i = (a); i >= (b); --i)
#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rof(i, a, b) for (int i = (a); i > (b); --i)
#define ll long long
#define db double
#define oo 0x3f3f3f3f
#define eps 0.00001
#define all(x) x.begin(), x.end()
#define met(a, b) memset(a, b, sizeof(a))
#define what_is(x) cerr << #x << " is " << x << endl
#define lowbit(x) x &(-x)
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 9999973;
int dp[1 << 16], a[22], sum[maxn], n, m;
int main()
{
	ios::sync_with_stdio(0);
	cin >> n >> m;
	_rep(i, 1, n)
	{
		cin >> a[i];
	}
	_rep(i, 1, m)
	{
		int xx;
		cin >> xx;
		sum[i] = sum[i - 1] + xx;
	}
	
	_rep(i, 0, (1<< n) - 1){
		_rep(j,1, n){
			if(!(i >> j - 1 & 1)){
				dp[i | 1 << j - 1] = max(dp[i | 1 << j - 1], (int)(upper_bound(sum + 1, sum + 1 + m, sum[dp[i]] + a[j]) - sum - 1));
			}
		}
	}
	ll ans = -1;
	_rep(i, 0, (1<< n)-1){
		if(dp[i] == m){
			ll tmp = 0;
			_rep(j, 1, n){
				if(!(i >> j - 1 & 1)){
					tmp += a[j];
				}
			}
			ans = max(ans , tmp);
		}
	}
	cout << ans << endl;
}
<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、付费专栏及课程。

余额充值