HDU动态规划——1114.Piggy-Bank，1121.Complete the Sequence，1158.Employment Planning

1114.Piggy-Bank（存钱罐）背包问题

问题 - 1114 (hdu.edu.cn)

题目描述

运行代码

#include <iostream>
using namespace std;
const int Max = 0x3f3f3f3f;  // 无穷大
int main() {
    int t;
    cin >> t;
    while (t--) {
        int before, after, v;
        cin >> before >> after;
       v = after - before;
        int n;
        cin >> n;
        int p[505], w[505];  // price, weight
        int dp[10005];  // 钱罐中的钱
        for (int i = 0; i < 10005; i++) {
            dp[i] = Max;
        }
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            cin >> p[i] >> w[i];
        }
        for (int i = 1; i <= n; i++) {
            for (int j = w[i]; j <= v; j++) {
                dp[j] = min(dp[j], dp[j - w[i]] + p[i]);
            }
        }
        if (dp[v] != Max) cout << "The minimum amount of money in the piggy-bank is " << dp[v] << "." << endl;
        else cout << "This is impossible." << endl;
    }

    return 0;
}

代码思路

1. 首先输入测试用例的数量 t ，然后进入 t 次循环处理每个测试用例。
2. 对于每个测试用例，输入空存钱罐重量 before 、装满硬币的存钱罐重量 after ，计算两者的差值 v 作为需要达到的目标重量。
3. 输入硬币的种类数量 n 。
4. 初始化一个 dp 数组，将其所有元素初始化为极大值 Max ，表示无法达到该状态。但将 dp[0] 初始化为 0 ，表示不装任何硬币时价值为 0 。
5. 输入每种硬币的价值 p[i] 和重量 w[i] 。
6. 通过两层循环来更新 dp 数组：外层循环遍历硬币种类，内层循环遍历从当前硬币重量到目标重量的所有可能重量。对于每个重量 j ，更新 dp[j] 为当前值和通过装入当前硬币所能达到的更小值中的较小者。

原理：
dp 数组用于记录达到每个重量时的最小价值。通过不断考虑每种硬币的加入，逐步更新 dp 数组，最终得到达到目标重量 v 时的最小价值。如果最终 dp[v] 仍然为极大值 Max ，则表示无法达到目标重量，输出“This is impossible. ”；否则输出达到目标重量时的最小价值 dp[v] 。

1121.Complete the Sequence（完成序列）

题目描述

问题 - 1121 (hdu.edu.cn)

运行代码

#include<iostream>
#include<cstdio>
using namespace std;
int main() {
    int T;
    int a[110][110];
    scanf_s("%d", &T);
    while (T--) {
        int i, j, s, c;
        scanf_s("%d%d", &s, &c);
        for (i = 1; i <= s; i++)
            scanf_s("%d", &a[1][i]);
        for (i = 2; i <= s; i++)
            for (j = s - 1; j >= 1; j--)
                a[i][j] = a[i - 1][j + 1] - a[i - 1][j];
        for (i = 2; i <= c + 1; i++)
            a[s][i] = a[s][1];
        for (i = s - 1; i >= 1; i--) {
            int t = s - i + 1 + c;
            for (j = s - i + 2; j <= t; j++)
                a[i][j] = a[i][j - 1] + a[i + 1][j - 1];
        }
        for (i = s + 1; i <= s + c - 1; i++)
            printf("%d ", a[1][i]);
        printf("%d\n", a[1][s + c]);
    }
    return 0;
}

代码思路

1. 首先，程序读取一个整数 T ，表示测试用例的数量。
2. 对于每个测试用例，定义一个二维数组 a ，并读取两个整数 s 和 c 。
3. 接下来通过循环读取 s 个整数，填充 a[1] 这一行。
4. 然后通过两层嵌套循环计算出 a 数组中前 s 行的其余元素，根据特定的差值规则进行计算。
5. 接着，对数组的最后一行进行一些处理，设置特定位置的元素值。
6. 再次通过循环计算数组后面的元素值。
7. 最后，输出计算得到的特定位置的元素值。

原理：

1. 整个代码的核心是通过一系列的循环和计算规则来构建和操作这个二维数组 a 。最初的循环用于读取基础数据并进行初步的计算，确定数组前部分的元素值。后续的循环则基于前面计算得到的结果，按照特定的规律继续填充和更新数组的元素。
2. 例如，在计算数组中元素的差值时，通过相邻元素的关系来推导后续的值。比如 a[i][j] = a[i - 1][j + 1] - a[i - 1][j] 这个式子，就是根据上一行相邻元素的差值来确定当前位置的元素。
3. 最后的输出部分，是根据前面的计算结果，按照指定的位置输出数组中的元素。

1158.Employment Planning

题目描述

Problem - 1158 (hdu.edu.cn)

运行代码

#include <iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int INF = 0x7fffffff;
int main() {
    int n, a, b, c;
    int num[12], dp[12][10000];
    while (cin >> n && n) {
        int high = -1;
        cin >> a >> b >> c;
        for (int i = 0; i < n; i++) {
            cin >> num[i];
            high = max(high, num[i]);
        }
        for (int i = num[0]; i <= high; i++) {
            dp[0][i] = i * (a + b);
        }
        for (int i = 1; i < n; i++) {
            for (int j = num[i]; j <= high; j++) {
                dp[i][j] = INF;
                for (int k = num[i - 1]; k <= high; k++) {
                    int cost1 = dp[i - 1][k] + a * (j - k) + j * b;
                    int cost2 = dp[i - 1][k] + c * (k - j) + j * b;
                    dp[i][j] = min(dp[i][j], k <= j ? cost1 : cost2);
                }
            }
        }
        int min1 = INF;
        for (int i = num[n - 1]; i <= high; i++) {
            min1 = min(dp[n - 1][i], min1);
        }
        cout << min1 << endl;
    }
}

代码思路

1. 首先，输入问题的规模 n 以及一些相关的参数 a、b、c。
2. 然后读取 n 个数字存入 num 数组，并找出这组数字中的最大值存为 high。
3. 初始化 dp[0][i] ，表示第一个位置的不同取值 i 对应的代价为 i * (a + b) 。
4. 接下来通过两层循环遍历后续的位置 i 和可能的取值 j 来计算 dp[i][j] 。对于每个位置和取值，通过内层的循环遍历前一个位置的可能取值 k ，计算两种情况下的代价：
   • 当 k <= j 时，代价为 dp[i - 1][k] + a * (j - k) + j * b 。
   • 当 k > j 时，代价为 dp[i - 1][k] + c * (k - j) + j * b 。然后取这两种情况中的较小值作为 dp[i][j] 。
5. 最后，在最后一个位置的可能取值中找到最小的代价并输出。

原理：
动态规划的核心思想是通过保存子问题的解来避免重复计算，从而提高效率。在这个问题中，dp[i][j] 表示在第 i 个位置取值为 j 时的最小代价。通过逐步计算每个位置和取值的最小代价，最终得到整个问题的最优解。