HDU 5501 The Highest Mark

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=5501

The Highest Mark

 

 Accepts: 32

 

 Submissions: 193

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 131072/131072 K (Java/Others)

问题描述

2045年的SD省队选拔，赛制和三十年前已是完全不同。一场比赛的比赛时间有 $t$ 分钟，有 $n$ 道题目。
第 $i$ 道题目的初始分值为 A_i(A_i \leq 10^{6})A​i​​(A​i​​≤10​6​​) 分，之后每过一分钟这道题目的分值会减少 B_iB​i​​ 分，并且保证到比赛结束时分值不会减少为负值。比如，一个人在第 $x$ 分钟结束时做出了第 $i$ 道题目，那么他/她可以得到 A_i - B_i * xA​i​​−B​i​​∗x 分。
若一名选手在第 $x$ 分钟结束时做完了一道题目，则他/她可以在第 $x+1$ 分钟开始时立即开始做另一道题目。
参加省队选拔的选手 dxy 具有绝佳的实力，他可以准确预测自己做每道题目所要花费的时间，做第 $i$ 道需要花费 C_i(C_i \leq t)C​i​​(C​i​​≤t) 分钟。由于 dxy 非常神，他会做所有的题目。但是由于比赛时间有限，他可能无法做完所有的题目。他希望安排一个做题的顺序，在比赛结束之前得到尽量多的分数。

输入描述

第一行为一个正整数 $T(T\le 10)$，表示数据组数($n>200$的数据不超过$5$组)。
对于每组数据，第一行为两个正整数 $n(n\le 1000)$ 和 $t(t\le 3000)$, 分别表示题目数量和比赛时间。接下来有 $n$ 行，每行 $3$ 个正整数依次表示 A_i, B_i, C_iA​i​​,B​i​​,C​i​​，即此题的初始分值、每分钟减少的分值、dxy做这道题需要花费的时间。

输出描述

对于每组数据输出一行一个整数，代表dxy这场比赛最多能得多少分

输入样例

1
4 10
110 5 9
30 2 1
80 4 8
50 3 2

输出样例

88

Hint

dxy先做第二题，再做第一题，第一题得分为$110-5\ast (1+9)=60$，第二题得分为$30-2\ast 1=28$，总得分为$88$，其他任何方案的得分都小于$88$

 

题解：

　　贪心+01背包。

贪心：

　　假设比赛时间无限大，每一道题目都能做完，那么你按照bi/ci由大到小排序的顺序完成所有题目会得到优成绩，

　　为什么呢？

　　　　任意两个相邻的题目i和j（i<j），先做i，你会多损失分数：ci*bj；先做j，你会多损失cj*bi，如果我们要先完成i，则有ci*bj<=cj*bi,即bi/ci>=bj/cj。

　　现在考虑有限时间内，如果最优解中的几个问题不是按照这个顺序来完成的，那么我们经过以上操作调整之后能使损失减小，从而得到更优解。

　　所以这个贪心是正确的。

dp:

　　贪心完之后，跑一遍01背包就可以了。

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 1010;
const int maxt = 3030;

struct Node {
    int a, b, c;
    bool operator < (const Node& tmp) {
        return b*tmp.c>c*tmp.b;
    }
}node[maxn];

int N, T;
int dp[maxn][maxt];

int main() {
    int tc;
    scanf("%d", &tc);
    while (tc--) {
        scanf("%d%d", &N, &T);
        for (int i = 1; i <= N; i++) {
            scanf("%d%d%d", &node[i].a, &node[i].b, &node[i].c);
        }
        sort(node + 1, node + N + 1);
        /*
        for(int i = 1; i <= N; i++) printf("%d ", node[i].a);
        printf("\n");
        */
        memset(dp[0], 0, sizeof(dp[0]));
        for (int i = 1; i <= N; i++) {
            for (int j = 0; j < node[i].c; j++) dp[i][j] = dp[i - 1][j];
            for (int j = node[i].c; j <= T; j++) {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - node[i].c]+node[i].a-node[i].b*j);
            }
        }
        int ans = 0;
        for (int i = 0; i <= T; i++) ans = max(ans, dp[N][i]);
        printf("%d\n", ans);
    }
    return 0;
}

 优化：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

const int maxn = 1010;
const int maxt = 3030;

struct Node {
    int a, b, c;
    bool operator < (const Node& tmp) {
        return b*tmp.c>c*tmp.b;
    }
}node[maxn];

int N, T;
int dp[maxt];

int main() {
    int tc;
    scanf("%d", &tc);
    while (tc--) {
        scanf("%d%d", &N, &T);
        for (int i = 1; i <= N; i++) {
            scanf("%d%d%d", &node[i].a, &node[i].b, &node[i].c);
        }
        sort(node + 1, node + N + 1);
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= N; i++) {
            for (int j = T; j >= node[i].c; j--) {
                dp[j] = max(dp[j], dp[j - node[i].c] + node[i].a - node[i].b*j);
            }
        }
        int ans = 0;
        for (int i = 0; i <= T; i++) ans = max(ans, dp[i]);
        printf("%d\n", ans);
    }
    return 0;
}