POJ 3709 K-Anonymous Sequence(斜率DP)

题意：给出一个n个数的非严格递增序列，每次操作可以将其中的一个数减一，问最少多少次操作，使得序列中的任何一个数在序列中至少都有k-1个数与之相同。

思路：对于a0显然不需要再减去了，设dp[i] : 前i个数满足条件并且第i个数为分界点时最少的操作次数，则有：

dp[i] = min { dp[j] + a[j+1] - a[j + 1] + a[j + 2] - a[j +1] + ... + a[i] - a[j + 1] | 0 <= j <= i - k } 

         = min { dp[j] + sum[i] - sum[j] - (i - j) * a[j + 1] | 0 <= j <= i - k }

 = min{ dp[j] - sum[j] - (i - j) * a[j + 1] | 0 <= j <= i - k } + sum[i]

即求 F(j) = dp[j] - sum[j] - (i - j) * a[j + 1]最小值， 可用斜率dp优化，但是加入点的时候要延迟加入。

#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <map>
#include <vector>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
typedef long long ll;
const int INF = 1e9 + 7;
const int maxn = 5e5 + 10;
const int maxm = 22;
using namespace std;

ll dp[maxn];
ll a[maxn];
ll sum[maxn];
ll f[maxn], x[maxn];
int n, m, T;
int que[maxn], num;

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        sum[0] = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
            sum[i] = sum[i - 1] + a[i];
        }
        dp[0] = num = 0;
        int head = 0, tail = 0;
        que[tail++] = 0;
        for(int I = 1; I <= n; I++) {
            int i = I;
            while(head < tail-1) {
                int j = que[head + 1];
                int k = que[head];
                if((f[j] - f[k]) > (x[j] - x[k]) * i) break;
                head++;
            }
            int id = que[head];
            if(i < m) dp[i] = INF;
            else dp[i] = dp[id] + sum[i] - sum[id] - a[id + 1] * (i - id);
            f[i] = dp[i] - sum[i] + a[i + 1] * i;
            x[i] = a[i + 1];
            ///延迟加入

            if(i >= 2 * m - 1) {
                i -= m - 1;
                while(head < tail-1) {
                    int j = que[tail - 1];
                    int k = que[tail - 2];
                    ll d1 = (f[j] - f[k]) * (x[i] - x[j]);
                    ll d2 = (f[i] - f[j]) * (x[j] - x[k]);
                    if(d1 < d2) break;
                    tail--;
                }
                que[tail++] = i;
            }
        }
        printf("%lld\n", dp[n]);
    }
    return 0;
}