HDU 2829 Lawrence（斜率优化DP O（n^2））

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2829

题目大意：有一段铁路有n个站，每个站可以往其他站运送粮草，现在要炸掉m条路使得粮草补给最小，粮草补给的公式是将每个站能收到的粮草的总和。

4----5-----1-----2

粮草总和为4*5 + 4*1 + 4*2 + 5*1 + 5*2 + 1*2 = 49.

4----5       1-----2

粮草总和为4*5 + 1*2 = 22. 

4      5-----1------2

粮草总和为5*1 + 5*2 + 1*2 = 17.

解题思路：数组dp[i][j]表示第i个位置炸成j段的最小价值，cost[i][j]表示i~j这段的价值，则得到状态转移方程：

　　　　　dp[i][j]=min{dp[k][j-1]+cost[k+1][i]}.(k<i)，复杂度为O（n^3）显然会超时

　　　　　易得cost[1][i]=cost[1][k]+cost[k+1][i]+sum[k]*(sum[i]-sum[k])

　　　　　则cost[k+1][i]=cost[1][i]-cost[1][k]+sum[k]^2-sum[k]*sum[i].

　　　　　使用cost[i]表示cost[1][i]得，dp[i][j]=min{dp[k][j-1]+cost[i]-cost[k]+sum[k]^2-sum[k]*sum[i]}.　　　

　　　　　可以得出 y=dp[k][j-1]-cost[1][k]+sum[k]^2

　　　　　x=sum[k].

　　　　　斜率sum[i]。

　　　　　用斜率优化，将复杂度降为O（n^2）即可。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1e3+5;
int dp[N][N],sum[N],cost[N],q[N],head,tail;

//yj-yk/xj-xk 
double Slope(int m,int k,int j){
    return double(dp[j][m-1]+sum[j]*sum[j]-cost[j]-dp[k][m-1]-sum[k]*sum[k]+cost[k])/(sum[j]-sum[k]);
}

//dp[i][j]=min{dp[k][j-1]+cost[i]-cost[k]-sum[k]*(sum[i]-sum[k])} 
int getDP(int i,int j,int k){
    return dp[k][j-1]+cost[i]-cost[k]-sum[k]*(sum[i]-sum[k]);
}

int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        if(m==0&&n==0)
            break;
        memset(cost,0,sizeof(cost));
        sum[0]=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&sum[i]);
            sum[i]+=sum[i-1];
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<i;j++){
                cost[i]+=(sum[j]-sum[j-1])*(sum[i]-sum[j]);
            }
            dp[i][1]=cost[i];
        }
        for(int j=2;j<=m+1;j++){
            head=tail=0;
            q[tail++]=j-1;
            for(int i=j;i<=n;i++){
                while(head+1<tail&&Slope(j,q[head],q[head+1])<=sum[i]){            
                    head++;
                }
                dp[i][j]=getDP(i,j,q[head]);
                while(head+1<tail&&Slope(j,q[tail-2],q[tail-1])>=Slope(j,q[tail-1],i)){
                    tail--;
                }
                q[tail++]=i;        
            }
        }
        printf("%d
",dp[n][m+1]);
    }
    return 0;
}