HDU-2829-Lawrence-dp-斜率优化

题意：一段直线上有n个点，每个点有一只价值，一条铁路的价值等于每两个点（可以直接或者间接相连，就是联通路上是否有炸弹把路给炸了）积的和；

思路：斜率优化

dp[i][j]为前i个点，炸j个线段能破坏的最大值

没优化前的状态转移方程为dp[i][x]=max{dp[j][x-1]+sum[j]*(sum[i]-sum[j])}  x-1<j<i //这里后半部分就是把j前的值和j后的值乘一下。

设计算点i时，j比k的值优，

dp[k][x-1]+sum[k]*(sum[i]-sum[k])<=dp[j][x-1]+sum[j]*(sum[i]-sum[j])

整理化简

((sum[j]*sum[j]-dp[j][x-1])-(sum[k]*sum[k]-dp[k][x-1]))/(sum[j]-sum[k])<=sum[i]

令yj=sum[j]*sum[j]-dp[j][x-1] 

xj=sum[j]

则式子变为(yj-yk)/(xj-xk)<=sum[i]

令g[j,k]=(yj-yk)/(xj-xk)

因为a[i]为正数所以sum[i]单调递增

当有g[j,k]<=sum[i]满足时，说明j比k优，而sum[i]单调递增所以比k可以淘汰

另外如果k<j<i 而g[j,k]>g[i,j] 则j可以淘汰

因为如果g[i,j]<sum[i]则i比j优，j本身就不用计算

而如果g[i,j]>sum[i]则g[j,k]>sum[i] 则说明k比j优所以j也被淘汰，综上j被淘汰

用一个队列可以维护一个小区间来确定i的时候需要确定的j值

代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
#define maxn 1111
int n,m;
int a[maxn];
int sum[maxn];
int dp[maxn][maxn];
int tot;
int gg[maxn];
//dp[i][x]=max{dp[j][x-1]+sum[j]*(sum[i)-sum[j]}  x-1<j<i
int getDP(int i,int j,int x) {   ///前i个点，炸掉x个点能破坏的最大值，炸了j后面的线段
    return dp[j][x-1]+sum[j]*(sum[i]-sum[j]);
}
int getUP(int j,int k,int x) {    ///斜率的上面一部分
    return sum[j]*sum[j]-dp[j][x-1]-(sum[k]*sum[k]-dp[k][x-1]);
}
int getDOWN(int j,int k) {         ///斜率的下面一部分
    return sum[j]-sum[k];
}
int main()
{
    while(scanf("%d%d",&n,&m)&&!(n==0&&m==0)) {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        memset(sum,0,sizeof sum);
        for(int i=1;i<=n;i++) {
            sum[i]=sum[i-1]+a[i];
        }
        tot=0;
        for(int i=2;i<=n;i++)
            tot+=a[i]*sum[i-1];

        memset(dp,0,sizeof dp);
        int head,wei;
        for(int x=1;x<=m;x++) {
            head=1;wei=2;
            gg[1]=x;
            for(int i=x+1;i<=n;i++) {
                while(head+1<wei&&getUP(gg[head+1],gg[head],x)<=sum[i]*getDOWN(gg[head+1],gg[head]))
                    head++;//如果j比k优之后都成立所以之前的可以淘汰
                dp[i][x]=getDP(i,gg[head],x);
                while(head+1<wei&&getUP(i,gg[wei-1],x)*getDOWN(gg[wei-1],gg[wei-2])<=getUP(gg[wei-1],gg[wei-2],x)*getDOWN(i,gg[wei-1]))
                    wei--;//g[k,j]>g[j,i] （k<j<i）那么j是可以淘汰的
                gg[wei++]=i;
            }
        }
        printf("%d\n",tot-dp[n][m]);
    }
    return 0;
}