hihocoder 1157 建造金字塔 (DP)

每个金字塔其实相当于一个区间，把这个区间按左端点排序，然后dp[i][j]表示，用到第i个金字塔，j表示覆盖到j，因为按左端点排序了，所以如果j被覆盖到，那么当前的i，往前肯定不会覆盖超过前面金字塔的覆盖，所以只要考虑后一部分的转移，转移具体见代码

代码：

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

typedef long long ll;

int t, n;

struct S {
    int l, r, w;
} s[1005];

bool cmp(S a, S b) {
    return a.l < b.l;
}

int cal(int x) {
    return x * x;
}

ll dp[2005];
const ll INF = 0x3f3f3f3f3f3f3f;

int main() {
    int cas = 0;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        int x, y, val;
        int Max = 0;
        for (int i = 0; i < n; i++) {
            scanf("%d%d%d", &x, &y, &val);
            s[i].l = x - y; s[i].r = x + y; s[i].w = val * 4;
            Max = max(Max, x + y);
        }
        sort(s, s + n, cmp);
        for (int i = 0; i <= Max; i++) dp[i] = -INF;
        for (int i = 0; i < n; i++) {
            for (int j = Max; j >= 0; j--) {
                if (j >= s[i].r) dp[j] = max(dp[j], dp[j] + s[i].w);
                else if (j >= s[i].l) dp[s[i].r] = max(dp[s[i].r], dp[j] + s[i].w + cal(j - s[i].l) - cal(s[i].r - s[i].l));
                else dp[s[i].r] = max(dp[s[i].r], dp[j] + s[i].w - cal(s[i].r - s[i].l));
            }
            dp[s[i].r] = max(dp[s[i].r], (ll)s[i].w - cal(s[i].r - s[i].l));
        }
        ll ans = 0;
        for (int i = 0; i <= Max; i++) ans = max(ans, dp[i]);
        printf("Case #%d: %.2f\n", ++cas, ans * 1.0 / 4);
    }
    return 0;
}