HDU1176——免费馅饼，HDU1203——I NEED A OFFER!，HDU1789——Doing Homework again

HDU1176——免费馅饼

题目描述

Problem - 1176 (hdu.edu.cn)

运行代码

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 15;
const int maxx = 100010;
int dp[maxx][maxn];

int main() {
    int n;
    while (cin >> n && n != 0) {
        int len = -100;
        fill(dp[0], dp[0] + maxx * maxn, 0);
        for (int i = 0; i < n; i++) {
            int s, t;
            cin >> s >> t;
            dp[t][s]++;
            len = max(len, t);
        }
        for (int i = len - 1; i >= 0; i--) {
            dp[i][0] += max(dp[i + 1][0], dp[i + 1][1]);
            dp[i][10] += max(dp[i + 1][10], dp[i + 1][9]);
            for (int pos = 1; pos <= 9; pos++) {
                dp[i][pos] += max({ dp[i + 1][pos], dp[i + 1][pos - 1], dp[i + 1][pos + 1] });
            }
        }
        cout << dp[0][5] << endl;
    }
    return 0;
}

代码思路

在给定一系列事件的开始时间和持续时间的情况下，求在特定位置（这里以位置 5 为例）能够达到的最大累计值。每个事件在特定时间点上对某个位置产生影响，而程序通过动态规划的方法计算从最后一个时间点向前推导，逐步确定每个时间点各个位置的最大累计值，最终得到初始时间点位置 5 的最大累计值。

1. 输入与初始化

   • while (cin >> n && n!= 0)：这是一个循环条件，只要输入的 n 不为 0，就继续循环。这样可以处理多组输入数据。
   • int len = -100;：初始化一个变量 len，用于记录最长的时间。初始值设为一个较小的值。
   • fill(dp[0], dp[0] + maxx * maxn, 0);：使用 fill 函数将二维数组 dp 初始化为全 0。这是动态规划中常见的初始化步骤，确保在计算之前数组处于已知的初始状态。

2. 读取事件信息并更新最长时间

   对于输入的每一个事件：
   • len = max(len, t);：更新最长时间 len，确保它始终是所有事件中最大的时间值。
   • dp[t][s]++;：表示在时间 t 位置 s 上的累计值增加 1。这里假设每个事件对相应位置的贡献为 1，可以根据实际情况修改这个值。
   • cin >> s >> t;：读取事件的起始位置 s 和时间 t。

3. 动态规划计算

   for (int i = len - 1; i >= 0; i--)：从最长时间减 1 开始向前遍历每个时间点，直到时间为 0。这是动态规划中常见的逆序遍历时间轴的方式。
   • for (int pos = 1; pos <= 9; pos++)：对于中间位置 1 到 9，它们可以从自身、左边位置或右边位置转移过来，所以取这三个位置在时间 i + 1 的最大累计值加到当前位置的累计值上。
   • dp[i][10] += max(dp[i + 1][10], dp[i + 1][9]);：同理，对于位置 10，只能从位置 9 或位置 10 转移过来。
   • dp[i][0] += max(dp[i + 1][0], dp[i + 1][1]);：对于位置 0，它只能从位置 0 或位置 1 转移过来，所以取这两个位置在时间 i + 1 的最大累计值加到当前位置的累计值上。

4. 输出结果cout << dp[0][5] << endl;：输出时间为 0 时位置 5 的最大累计值，这是程序最终要得到的结果。

利用动态规划的思想，通过逐步计算每个时间点各个位置的最大累计值，有效地解决了给定一系列事件情况下在特定位置的累计值最大化问题。其关键在于正确地定义状态（时间和位置的组合）、状态转移方程（根据不同位置的转移可能性确定）以及合理的初始化和遍历顺序。

HDU1203——I NEED A OFFER!

题目描述

Problem - 1203 (hdu.edu.cn)

Problem Description

Speakless很早就想出国，现在他已经考完了所有需要的考试，准备了所有要准备的材料，于是，便需要去申请学校了。要申请国外的任何大学，你都要交纳一定的申请费用，这可是很惊人的。Speakless没有多少钱，总共只攒了n万美元。他将在m个学校中选择若干的（当然要在他的经济承受范围内）。每个学校都有不同的申请费用a（万美元），并且Speakless估计了他得到这个学校offer的可能性b。不同学校之间是否得到offer不会互相影响。“I NEED A OFFER”，他大叫一声。帮帮这个可怜的人吧，帮助他计算一下，他可以收到至少一份offer的最大概率。（如果Speakless选择了多个学校，得到任意一个学校的offer都可以）。

 

Input

输入有若干组数据，每组数据的第一行有两个正整数n,m(0<=n<=10000,0<=m<=10000)
后面的m行，每行都有两个数据ai(整型),bi(实型)分别表示第i个学校的申请费用和可能拿到offer的概率。
输入的最后有两个0。

 

Output

每组数据都对应一个输出，表示Speakless可能得到至少一份offer的最大概率。用百分数表示，精确到小数点后一位。

 

Sample Input

10 3

4 0.1

4 0.2

5 0.3

0 0

Sample Output

44.0%

运行代码

#include <iostream>
using namespace std;
float minFunc(float a, float b) {
    return a < b ? a : b;
}

int main() {
    int all_money, test, i, j;
    int money[10010];
    float rate[10010], dp[10010];

    while (cin >> all_money >> test && (all_money || test)) {
        for (i = 1; i <= test; i++) {
            cin >> money[i] >> rate[i];
        }

        for (i = 0; i <= all_money; i++) {
            dp[i] = 1.0;
        }

        for (i = 1; i <= test; i++) {
            for (j = all_money; j >= money[i]; j--) {
                dp[j] = minFunc(dp[j], dp[j - money[i]] * (1 - rate[i]));
            }
        }

        cout.precision(1);
        cout << fixed << (1 - dp[all_money]) * 100 << "%" <<endl;
    }

    return 0;
}

代码思路

该程序的目的可能是根据给定的总金额和一系列物品（每个物品有价格和折扣率），计算出在满足总金额限制的情况下，通过购买物品所能获得的最大折扣后的剩余金额比例，并以百分比形式输出。

1. 函数定义：minFunc函数用于比较两个浮点数并返回较小的值。

2. main函数部分

   • 变量定义：all_money表示总金额。test表示物品的数量。i和j用于循环控制。money数组用于存储每个物品的价格。rate数组用于存储每个物品的折扣率。dp数组用于动态规划计算，存储不同金额下的最小剩余金额比例。
   • 循环读取输入：使用while (cin >> all_money >> test && (all_money || test))循环，不断读取总金额和物品数量，只要输入不是两个 0 就继续循环。
   • 读取物品信息：对于每个物品，使用循环for (i = 1; i <= test; i++)读取物品的价格和折扣率存入money和rate数组。
   • 初始化dp数组：使用循环for (i = 0; i <= all_money; i++)将dp数组的每个元素初始化为 1.0，表示初始状态下没有进行任何购买时，剩余金额比例为 100%。
   • 动态规划计算：使用两层嵌套循环进行动态规划计算。外层循环for (i = 1; i <= test; i++)遍历每个物品，内层循环for (j = all_money; j >= money[i]; j--)从总金额开始递减，对于每个金额j，计算不购买当前物品和购买当前物品两种情况下的最小剩余金额比例，取两者中的较小值存入dp[j]。计算公式为dp[j] = minFunc(dp[j], dp[j - money[i]] * (1 - rate[i]))。
   • 输出结果：使用cout.precision(1)设置输出精度为一位小数，cout << fixed << (1 - dp[all_money]) * 100 << "%" << endl;计算并输出折扣后的剩余金额比例，以百分比形式显示。

HDU1789——Doing Homework again

题目描述

Problem - 1789 (hdu.edu.cn)

运行代码

#include <iostream>
#include <algorithm>
using namespace std;
struct Homework {
    int deadline;
    int score;
};
bool compare(Homework a, Homework b) {
    return a.score > b.score;
}
int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        Homework homeworks[1000];
        for (int i = 0; i < n; i++) {
            cin >> homeworks[i].deadline;
        }
        for (int i = 0; i < n; i++) {
            cin >> homeworks[i].score;
        }
        sort(homeworks, homeworks + n, compare);
        bool days[1000];
        fill(days, days + n, false);
        int total= 0;
        for (int i = 0; i < n; i++) {
            int d = homeworks[i].deadline;
            while (d > 0 && days[d - 1]) {
                d--;
            }
            if (d > 0) {
                days[d - 1] = true;
            }
            else {
                total += homeworks[i].score;
            }
        }
        cout << total << endl;
    }
    return 0;
}

代码思路

该程序的目的是帮助 Ignatius 安排作业顺序，以尽量减少因延迟交作业而降低的分数。给定作业数量、每个作业的截止日期和延迟交作业的降低分数，通过合理安排作业顺序，输出最小的总降低分数。

1. 定义结构体和比较函数定义了一个名为Homework的结构体，包含两个成员变量：deadline表示作业的截止日期，score表示延迟交作业降低的分数。定义了一个比较函数compare，用于对Homework结构体按照score从大到小进行排序。

2. main函数部分

   • 输入测试用例数量：首先从输入中读取一个整数t，表示测试用例的数量。
   • 处理每个测试用例：对于每个测试用例，先读取作业数量n。然后使用两个循环分别读取每个作业的截止日期和降低分数，并存储在homeworks数组中。
   • 排序作业：使用std::sort函数结合自定义的比较函数compare对homeworks数组进行排序，使得降低分数高的作业排在前面。
   • 安排作业：创建一个布尔数组days，用于表示每一天是否被安排了作业，初始状态下所有元素都为false。遍历排序后的作业数组：如果在截止日期内找不到未被安排的日子，就将该作业的降低分数累加到总降低分数total中。在截止日期范围内，从后往前查找第一个未被安排作业的日子。如果找到了这样的日子，就将该天标记为已安排作业（days[d - 1] = true）。对于每个作业，获取其截止日期d。
   • 输出结果：输出每个测试用例的最小总降低分数。