记录81
#include<bits/stdc++.h>
using namespace std;
int dp[2010][2010];
int main(){
int n,m;
cin>>n>>m;//看清行列
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++) cin>>dp[i][j];
}
for(int j=1;j<=n;j++){//按步骤最优情况来找状态转移
for(int i=1;i<=m;i++){//竖着找
if(i==1) dp[i][j]+=min(dp[m][j-1],dp[i][j-1]);
else dp[i][j]+=min(dp[i-1][j-1],dp[i][j-1]);
}//第一行单独处理
}//从左边转移,或者从左上角转移
int t=dp[1][n];//最后步骤中最小的
for(int i=2;i<=m;i++) t=min(t,dp[i][n]);
cout<<t;
return 0;
}
题目传送门
https://www.luogu.com.cn/problem/P1130
突破口
这 M×N 个工作人员被分成 M 个小组。每一组在每一步都有一个工作人员。申请人可以选择任意一个小组也可以更换小组。但是更换小组是很严格的,一定要相邻两个步骤之间来更换,而不能在某一步骤已经开始但还没结束的时候提出更换,并且也只能从原来的小组 I 更换到小组 I+1,当然从小组 M 可以更换到小组 1。对更换小组的次数没有限制。
思路
🎯 问题本质
- 有 N 个步骤(从第 1 步到第 N 步)
- 有 M 个小组(编号 1 到 M)
- 每个小组在每一步都有一个工作人员,耗时已知(
cost[i][j]= 小组 i 做第 j 步的天数) - 你可以选择任意小组开始,并在相邻步骤之间切换小组
- 切换规则:
- 只能在步骤之间切换(不能中途换)
- 只能从小组
i换到i+1,或从M换到1(即环形相邻)
✅ 目标:完成所有 N 步的最小总天数
🧠 关键观察:动态规划设计
1. 状态定义
设 dp[i][j] 表示:完成前 j 步,且第 j 步由小组 i 完成的最小总天数
2. 状态转移
第 j 步由小组 i 完成,那么第 j−1 步只能由以下小组完成:
- 小组 i(不换组)
- 小组 i−1(从 i−1 换到 i)
- 特殊:如果 i=1,则前一步可以是小组 M(因为 M → 1 是允许的)
所以:
- 若
i == 1:
dp[1][j] = cost[1][j] + min(dp[M][j-1], dp[1][j-1]) - 若
i > 1:
dp[i][j] = cost[i][j] + min(dp[i-1][j-1], dp[i][j-1])
⚠️ 注意:不能从 i+1 换到 i!题目规定只能换到 I+1,即:
- 第 j−1 步在小组 k,第 j 步可以在 k 或 k+1(模 M)
- 等价于:第 j 步在 i,第 j−1 步只能在 i 或 i−1(模 M)
✅ 所以转移来源只有两个:同组 或 前一组(环形)
3. 初始化
- 第 1 步(j=1):
dp[i][1] = cost[i][1](没有前一步,直接开始)
4. 答案
min(dp[1][N], dp[2][N], ..., dp[M][N])
代码分析
✅ 代码逐行解释
#include<bits/stdc++.h>
using namespace std;
int dp[2010][2010];
- 定义 DP 表,
dp[i][j]:小组 i 完成第 j 步的最小累计天数 - 数组大小 2010×2010(满足 N, M ≤ 2000)
int main(){
int n, m;
cin >> n >> m; // n=步数, m=小组数
- 注意:n 是列(步骤),m 是行(小组)
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++)
cin >> dp[i][j];
}
- 直接把输入的耗时存入
dp[i][j](此时dp[i][j] = cost[i][j]) - 后续会在原数组上累加,节省空间
🔥 核心:按步骤(j)递推
for(int j = 1; j <= n; j++){ // 遍历每一步
for(int i = 1; i <= m; i++){ // 遍历每个小组
- 外层循环按步骤 j 从小到大(必须!因为 j 依赖 j−1)
- 内层处理每个小组 i 在第 j 步的情况
if(i == 1)
dp[i][j] += min(dp[m][j-1], dp[i][j-1]);
else
dp[i][j] += min(dp[i-1][j-1], dp[i][j-1]);
- 当 j=1 时:
j-1 = 0,但dp[*][0]未初始化?- 实际上,j 从 1 开始,但 j=1 时不应执行加法!
- ❗ 这里多注意!
💡 因为全局数组
dp初始化为 0,所以dp[*][0] = 0,恰好让 j=1 时加 0,结果正确
这属于“内存存储情况的把控”
// 初始化 j=1
for (int i=1; i<=m; i++) dp[i][1] = cost[i][1];
// 从 j=2 开始递推
for (int j=2; j<=n; j++) {
for (int i=1; i<=m; i++) {
if (i == 1)
dp[i][j] += min(dp[m][j-1], dp[i][j-1]);
else
dp[i][j] += min(dp[i-1][j-1], dp[i][j-1]);
}
}
🔚 输出答案
int t = dp[1][n];
for(int i = 2; i <= m; i++)
t = min(t, dp[i][n]);
cout << t;
return 0;
}
- 在最后一列(第 N 步)中找最小值
- 输出最少总天数
🧪 样例验证:输入
4 3
2 6 1 8
3 6 2 6
4 2 3 6
初始 dp(即 cost):
dp[1] = [2, 6, 1, 8]
dp[2] = [3, 6, 2, 6]
dp[3] = [4, 2, 3, 6]
j=1:保持不变
→ dp[*][1] = [2, 3, 4]
j=2:
- i=1: dp[1][2] = 6 + min(dp[3][1], dp[1][1]) = 6 + min(4,2) = 8
- i=2: dp[2][2] = 6 + min(dp[1][1], dp[2][1]) = 6 + min(2,3) = 8
- i=3: dp[3][2] = 2 + min(dp[2][1], dp[3][1]) = 2 + min(3,4) = 5
j=3:
- i=1: 1 + min(dp[3][2]=5, dp[1][2]=8) = 6
- i=2: 2 + min(8,8) = 10
- i=3: 3 + min(8,5) = 8
j=4:
- i=1: 8 + min(dp[3][3]=8, dp[1][3]=6) = 14
- i=2: 6 + min(6,10) = 12
- i=3: 6 + min(10,8) = 14
→ 最小值 = min(14,12,14) = 12 ✅
✅ 总结
| 要点 | 说明 |
|---|---|
| 状态设计 | dp[i][j] = 小组 i 完成第 j 步的最小总天数 |
| 转移来源 | 同组 i 或前一组 i−1(i=1 时前一组是 M) |
| 边界处理 | j=1 时无前驱,靠 dp[*][0]=0 巧合正确 |
| 答案 | min(dp[1..M][N]) |
| 复杂度 | O(N×M),满足 2000×2000 = 4e6 |
💡这段是一道典型的带环形转移的动态规划问题
326



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



