问题描述
小R正在计划一次从地点A到地点B的徒步旅行，总路程需要 N 天。为了在旅途中保持充足的能量，小R每天必须消耗1份食物。幸运的是，小R在路途中每天都会经过一个补给站，可以购买食物进行补充。然而，每个补给站的食物每份的价格可能不同，并且小R最多只能同时携带 K 份食物。
现在，小R希望在保证每天都有食物的前提下，以最小的花费完成这次徒步旅行。你能帮助小R计算出最低的花费是多少吗？
测试样例
样例1：
输入：
n = 5 ,k = 2 ,data = [1, 2, 3, 3, 2]
输出：9
样例2：
输入：
n = 6 ,k = 3 ,data = [4, 1, 5, 2, 1, 3]
输出：9
样例3：
输入：
n = 4 ,k = 1 ,data = [3, 2, 4, 1]
输出：10
思路分析
这个问题可以通过动态规划来解决。我们需要找到一种方法，使得在每一天都能以最小的花费购买足够的食物，同时不超过携带上限 K。
-
状态定义：
dp[i][j]表示在第i天结束时，携带j份食物的最小花费。
-
状态转移方程：
- 对于
dp[i][j]，我们可以根据前一天留有食物的多少得到。对于每一天i，我们需要考虑在前一天结束时携带的食物数量w，并计算出在第i天购买j - w + 1份食物的花费，即在在第i天结束时，携带j份食物的最小花费。。 - 转移方程为：
dp[i][j] = Math.min(dp[i][j], dp[i - 1][w] + (j - w + 1) * data[i])，其中w的范围是从1到j + 1。
- 对于
-
初始化：
- 初始化第0天的状态，即
dp[0][i] = i * data[0]，表示在第0天购买i份食物的花费。 - 对于超出携带上限的状态，初始化为一个很大的值（如
0x3f3f3f3f），表示不可达状态。
- 初始化第0天的状态，即
-
最终结果：
- 最终结果为
dp[n - 1][1]，即在最后一天前一天结束时，携带1份食物的最小花费，最后一份食物将在到终点的那天吃完。
- 最终结果为
代码实现
public class Main {
public static int solution(int n, int k, int[] data) {
int[][] dp = new int[n + 10][k + 10];
// 初始化第0天的状态
for (int i = 1; i <= k; i++) dp[0][i] = i * data[0];
// 初始化超出携带上限的状态
for (int i = 0; i < n; i++) dp[i][k + 1] = 0x3f3f3f3f;
// 动态规划状态转移
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] = 0x3f3f3f3f;
for (int w = 1; w <= j + 1; w++) {
dp[i][j] = Math.min(dp[i][j], dp[i - 1][w] + (j - w + 1) * data[i]);
}
}
}
// 返回最终结果
return dp[n - 1][1];
}
public static void main(String[] args) {
// 测试样例
System.out.println(solution(5, 2, new int[]{1, 2, 3, 3, 2}) == 9);
}
}
复杂度分析
- 时间复杂度：
O(n * k^2)，其中n是天数，k是最大携带食物数量。 - 空间复杂度：
O(n * k)，用于存储动态规划的状态。
优化空间
- 滚动数组：我们只需要保留前一天的状态，而不需要保留所有天的状态。因此，可以将二维数组
dp优化为一维数组。 - 状态更新：在更新当前天的状态时，只需要使用前一天的状态。
public class Main {
public static int solution(int n, int k, int[] data) {
// Edit your code here
int[] dp = new int[k + 10];
for (int i = 1; i <= k; i ++ ) dp[i] = i * data[0];
dp[k + 1] = 0x3f3f3f3f;
for (int i = 1; i < n; i ++ ) {
int[] new_dp = new int[k + 10];
new_dp[k + 1] = 0x3f3f3f3f;
for (int j = 1; j <= k; j ++ ) {
new_dp[j] = 0x3f3f3f3f;
for (int w = 1; w <= j + 1; w ++ ) {
new_dp[j] = Math.min(new_dp[j], dp[w] + (j - w + 1) * data[i]);
}
}
dp = new_dp;
}
return dp[1];
}
public static void main(String[] args) {
// Add your test cases here
System.out.println(solution(5, 2, new int[]{1, 2, 3, 3, 2}) == 9);
}
}
复杂度分析
- 时间复杂度：
O(n * k^2)，与之前相同。 - 空间复杂度：
O(k)，因为我们只使用了两个长度为k + 1的数组来存储状态。
通过这种优化，我们显著减少了空间的使用，同时保持了时间复杂度不变。
