记录90
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N],dp[N][2];//0跳层 1爬楼
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
dp[0][0]=INT_MAX;//跳到0层不具备现实意义
dp[0][1]=0;//爬0层等于没动
dp[1][0]=0;//跳一层可以,不花费时间
dp[1][1]=dp[0][1]+a[1];//爬1层:从0层+1层高
for(int i=2;i<=n;i++){//两种方式到达i层
dp[i][0]=min(dp[i-1][1],dp[i-2][1]);// 跳跃后必须爬楼,所以只能从爬楼状态转移
dp[i][1]=min(dp[i-1][0],dp[i-1][1])+a[i];// 爬到这一楼的之前情况(跳/爬)+爬这楼
}
cout<<min(dp[n][0],dp[n][1]);
return 0;
}
题目传送门
https://www.luogu.com.cn/problem/P2800
突破口
锁妖塔共有 n 层,第 i 层的高度为 hi。小 A 初始时在地面上,他爬上第 i 层需要花费的时间等于该层高度 hi。小 A 会用仙术,每用一次可以让他向上跳一层或两层,该过程不花费时间。但是每次跳跃后小 A 都将用完力气,必须再爬过至少一层休息才可以继续使用仙术跳跃。
现在小 A 想让你帮他算出爬上塔顶(第 n 层)的最短时间。
思路
🎯 问题目标
小 A 要从地面(第 0 层)爬到第 n 层塔顶,每层有高度 h[i]。
- 爬一层:花费
h[i]时间 - 使用仙术跳 1 层或 2 层:不花时间,但跳跃后必须至少爬一层才能再次跳跃
✅ 关键约束:不能连续跳跃!
即:跳跃 → 必须爬 → 才能再跳
这本质上是一个带状态限制的最短路径问题,适合用 动态规划(DP),并记录当前是否刚跳过。
🧠 动态规划设计
状态定义
我们定义两个状态(按“到达第 i 层时的最后动作”分类):
dp[i][0]:通过跳跃到达第i层的最小总时间dp[i][1]:通过爬行到达第i层的最小总时间
💡 为什么这样分?
因为“能否下次跳跃”取决于上一步是不是爬。
而dp[i][1]表示最后是爬的 → 下一步可以跳;
dp[i][0]表示最后是跳的 → 下一步不能跳,必须爬
状态转移
1. 如何跳到第 i 层?(dp[i][0])
- 只能从 第 i−1 层或 i−2 层 跳过来
- 但跳跃前必须是“爬”的状态(因为跳完必须爬,反过来:要跳,前一步必须是爬)
- 所以:
dp[i][0]=min(dp[i−1][1], dp[i−2][1])dp[i][0]=min(dp[i−1][1], dp[i−2][1])
2. 如何爬到第 i 层?(dp[i][1])
- 只能从 第 i−1 层 爬上来(爬只能一层一层)
- 上一步可以是跳或爬(爬行不要求前置状态)
- 爬第 i 层需加
a[i]时间:
dp[i][1]=min(dp[i−1][0], dp[i−1][1])+a[i]dp[i][1]=min(dp[i−1][0], dp[i−1][1])+a[i]
初始条件
dp[0][1] = 0:在地面(0 层),没动,视为“爬”状态(合法起点)dp[0][0] = INF:不可能“跳”到 0 层(无意义)- 第 1 层:
- 跳到 1 层:
dp[1][0] = dp[0][1] = 0(从地面跳 1 层) - 爬到 1 层:
dp[1][1] = dp[0][1] + a[1] = a[1]
- 跳到 1 层:
最终答案
- 到达第
n层可以是跳 or 爬:
ans=min(dp[n][0], dp[n][1])ans=min(dp[n][0], dp[n][1])
代码分析
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N], dp[N][2]; // dp[i][0]=跳到i, dp[i][1]=爬到i
int main(){
int n;
cin >> n;
for(int i = 1; i <= n; i++) cin >> a[i];
🔹 初始化边界(第 0 层和第 1 层)
dp[0][0] = INT_MAX; // 跳到0层:非法,设为无穷大
dp[0][1] = 0; // 地面,初始状态,时间为0
dp[1][0] = 0; // 从0层跳1层到1层,时间0
dp[1][1] = dp[0][1] + a[1]; // 从0层爬1层,时间 = 0 + a[1]
🔁 从第 2 层开始递推
for(int i = 2; i <= n; i++){
dp[i][0] = min(dp[i-1][1], dp[i-2][1]);
- 跳到 i 层:只能从 i−1 或 i−2 跳,且前一步必须是“爬”(
[1]状态)
dp[i][1] = min(dp[i-1][0], dp[i-1][1]) + a[i];
- 爬到 i 层:从 i−1 来,前一步可跳可爬,加上本层高度
}
🔚 输出答案
cout << min(dp[n][0], dp[n][1]);
return 0;
}
🧪 样例验证:n=5, a = [3,5,1,8,4]
| i | a[i] | dp[i][0](跳) | dp[i][1](爬) |
|---|---|---|---|
| 0 | — | ∞ | 0 |
| 1 | 3 | 0 | 0+3=3 |
| 2 | 5 | min(dp[1][1]=3, dp[0][1]=0) = 0 | min(0,3)+5 = 5 |
| 3 | 1 | min(dp[2][1]=5, dp[1][1]=3) = 3 | min(0,5)+1 = 1 |
| 4 | 8 | min(dp[3][1]=1, dp[2][1]=5) = 1 | min(3,1)+8 = 9 |
| 5 | 4 | min(dp[4][1]=9, dp[3][1]=1) = 1 | min(1,9)+4 = 5 |
→ min(dp[5][0]=1, dp[5][1]=5) = 1 ✅
💡 最优路径:
跳到1(0)→ 爬2(+5)→ 跳到3(0)→ 爬4(+8)→ 跳到5(0)?
但根据 DP,实际是:
地面 → 跳1(0)→ 跳2?❌ 不行!不能连续跳!
正确路径(对应 dp[5][0]=1):
- 地面 → 爬1(3)→ 跳3(0)→ 爬4(8)→ 跳5(0)?总时间 3+8=11 ❌
等等,哪里出错了?
再看 dp[3][1] = 1:
- 来自
min(dp[2][0]=0, dp[2][1]=5) + a[3]=1→0+1=1 dp[2][0]=0表示跳到2层(从地面跳2层?但 n≥2 时允许跳2层!)
✅ 正确路径:
- 地面 → 跳2层(到第2层,时间0)→ 爬3层(+1)→ 跳5层(时间不变)
- 总时间 = 1
但题目说“跳1层或2层”,所以从地面可以直接跳到第2层!
然后爬第3层(h=1),再跳2层到第5层。
完全合法!输出 1 ✅
总结
| 要点 | 说明 |
|---|---|
| 状态设计 | dp[i][0](跳到 i),dp[i][1](爬到 i) |
| 转移关键 | 跳只能从“爬”状态转移;爬可以从任意状态转移 |
| 初始条件 | dp[0][1]=0 是合法起点 |
| 复杂度 | O(n),满足 n ≤ 1e6 |
| 易错点 | 不能连续跳 → 跳的前一步必须是爬 |
这段代码精准建模了“跳-爬”交替的约束,是状态机 DP 的典型应用。
931



被折叠的 条评论
为什么被折叠?



