POJ - 3709 K-Anonymous Sequence(斜率优化)

题目大意：给出N个递增数字，要求你将这些数字进行分组，每组至少要K个，且每一组的数字都要相同，数字只能减少，不能增加，变化的代价就是（该数-要变化的数字）
问最少的变化代价和

解题思路：设dp[i]为前i个数字分好组后的最小变化代价和
得到转移方程dp[i] = dp[j] + sum[i] - sum[j] - (i - j) * val[j + 1]
sum[i]表示前i个数字和，val[i]表示第i个数字的值
设k > j且点k比点j优
则 dp[j] + sum[i] - sum[j] - (i - j) * val[j + 1] >= dp[k] + sum[i] - sum[k] - (i - k) * val[k + 1]
化简后得到(dp[k] - sum[k] + k * val[k + 1] - dp[j] + sum[j] - j * val[j + 1]) / (val[k + 1] - val[j + 1]) <= i
因为i递增，所以得到斜率方程

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 500010;

typedef long long LL;

LL sum[N], dp[N], val[N];
int que[N];
int n, m;

void init() {
    scanf("%d%d", &n, &m);
    sum[0] = 0;
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &val[i]);
        sum[i] = sum[i - 1] + val[i];
    }
}

LL getUp(int k, int j) {
    return (dp[k] - sum[k]) - (dp[j] - sum[j]) + k * val[k + 1] - j * val[j + 1];
}

LL getDown(int k, int j) {
    return val[k + 1] - val[j + 1];
}

void getDp(int i, int j) {
    dp[i] = dp[j] + sum[i] - sum[j] - (i - j) * val[j + 1];
}

void solve() {
    dp[0] = 0;
    int head, tail;
    head = tail = 0;
    que[tail++] = 0;

    for (int i = 1; i <= n; i++) {
        while (head + 1 < tail && getUp(que[head + 1], que[head]) <= getDown(que[head + 1], que[head]) * i) head++;
        getDp(i, que[head]);
        if (i >= 2 * m - 1) {
            int t  = i - m + 1;
            while (head + 1 < tail && getUp(t, que[tail - 1]) * getDown(que[tail - 1], que[tail - 2]) <= getUp(que[tail - 1], que[tail - 2]) * getDown(t, que[tail - 1])) tail--;
            que[tail++] = t;
        }
    }
    printf("%lld\n", dp[n]);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();
        solve();
    }
    return 0;
}