734. 能量石

岩石怪物杜达生活在魔法森林中，他在午餐时收集了 N 块能量石准备开吃。

由于他的嘴很小，所以一次只能吃一块能量石。

能量石很硬，吃完需要花不少时间。

吃完第 i 块能量石需要花费的时间为 Si 秒。

杜达靠吃能量石来获取能量。

不同的能量石包含的能量可能不同。

此外，能量石会随着时间流逝逐渐失去能量。

第 i 块能量石最初包含 Ei 单位的能量，并且每秒将失去 Li 单位的能量。

当杜达开始吃一块能量石时，他就会立即获得该能量石所含的全部能量（无论实际吃完该石头需要多少时间）。

能量石中包含的能量最多降低至 0。

请问杜达通过吃能量石可以获得的最大能量是多少？

输入格式

第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含整数 N，表示能量石的数量。

接下来 N 行，每行包含三个整数 Si,Ei,Li。

输出格式

每组数据输出一个结果，每个结果占一行。

结果表示为 Case #x: y，其中 x 是组别编号（从 1 开始），y 是可以获得的最大能量值。

数据范围

1≤T≤10,
1≤N≤100,
1≤Si≤100,
1≤Ei≤105,
0≤Li≤105

输入样例：

3
4
20 10 1
5 30 5
100 30 1
5 80 60
3
10 4 1000
10 3 1000
10 8 1000
2
12 300 50
5 200 0

输出样例：

Case #1: 105
Case #2: 8
Case #3: 500

样例解释
在样例＃1中，有 N=4 个宝石。杜达可以选择的一个吃石头顺序是：

吃第四块石头。这需要 5 秒，并给他 80 单位的能量。
吃第二块石头。这需要 5 秒，并给他 5 单位的能量（第二块石头开始时具有 30 单位能量，5 秒后失去了 25 单位的能量）。
吃第三块石头。这需要 100 秒，并给他 20 单位的能量（第三块石头开始时具有 30 单位能量，10 秒后失去了 10 单位的能量）。
吃第一块石头。这需要 20 秒，并给他 0 单位的能量（第一块石头以 10 单位能量开始，110 秒后已经失去了所有的能量）。
他一共获得了 105 单位的能量，这是能获得的最大值，所以答案是 105。

在样本案例＃2中，有 N=3 个宝石。

无论杜达选择吃哪块石头，剩下的两个石头的能量都会耗光。

所以他应该吃第三块石头，给他提供 8 单位的能量。

在样本案例＃3中，有 N=2 个宝石。杜达可以：

吃第一块石头。这需要 12 秒，并给他 300 单位的能量。
吃第二块石头。这需要 5 秒，并给他 200 单位的能量（第二块石头随着时间的推移不会失去任何能量！）。
所以答案是 500。

思路：

/*
首先为什么这题目不能直接用01背包dp呢？因为对于吃相同的几个能量石，吃的顺序不同，最后吃到的能量也不同，所以我们要把所有能量石按照能吃到的最大能量的顺序去排序，再用dp得出来的就是最优解。

这道题思路是一个贪心加dp的方法，怎么贪心是一个问题，贪心是对于一个问题发现它的性质，然后简化问题的一个思想，所以我们要看看题目到底有什么性质可以用。

对于两块能量石 i 和 i+1
先吃 i 的能吃到的能力为 e(i)+e(i+1)-s(i) * l(i+1),
后吃 i 号能量石的能量为e(i)+e(i+1)-s(i+1) * l(i）
这样比较下来 当s(i) * l(i+1) < s(i+1) * l(i）时先吃 i ，反之吃 i+1；

所以我们可以利用贪心来对所有的能量石排序，这样问题就变成了按照一个线性顺序取对每一个能量石判断是否拿取的问题了，就变成了经典的01背包问题

还有一个是总时间 m的取值问题，因为我们状态定义的是前i个能量石中取，经过了恰好 j 时刻的解，所以只要找出 j 最大可能是多少就可以了，就是所有能量石时间总和

令f[i][j]为从前i个能量石中取，经过了恰好 j 时刻的解
状态转移方程 f[i][j] = max(f[i][j], f[i - 1][j - s] + max(0, e - l * (j - s)));

解释一下里面的细节：首先吃第i个能量石的时刻已经过了 j-s 的时间了，因为能力石的能力不为负数，所以和0取一个max

由于我们不知道刚好进过哪一个时刻是解最大的时候 ，所以对每一个时间遍历，找出最大值
*/

代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 10010;

struct Stone
{
    int s, e, l;
    bool operator<(const Stone &b) const
    {
        return s * b.l < b.s * l;
    }
} stone[N];

int T;
int n;
int f[M];
int main()
{
    cin >> T;
    for (int i = 1; i <= T; i++)
    {
        cin >> n;
        int m = 0;
        for (int j = 0; j < n; j++)
        {
            int s, e, l;
            cin >> s >> e >> l;
            stone[j] = {s, e, l};
            m += s;
        }

        sort(stone, stone + n);

        memset(f, -0x3f, sizeof(f));
        f[0] = 0;

        for (int k = 0; k < n; k++)
        {
            int s = stone[k].s, e = stone[k].e, l = stone[k].l;
            for (int j = m; j >= s; j--)
                f[j] = max(f[j], f[j - s] + e - (j - s) * l);
        }

        int res = 0;
        for (int k = 0; k <= m; k++)
        {
            if (f[k] > f[res])
                res = k;
        }
        printf("Case #%d: %d\n", i, f[res]);
    }

    return 0;
}