【HDU 2829】 Lawrences

这道题可以首先预处理出1~i个节点的value

设s[i]为前i个节点权值之和，w[i]为前i个节点连通之时的价值之和

则s[i]=s[i-1]+a[i],w[i]=w[i-1]+s[i-1]*a[i];

有了这两个辅助数组之后，就可以在O(1)求出任意起点和终点连通时价值之和了

设val[j,i]为起点为j，终点为i的权值之和

则val[j,i]=w[i]-w[j]-(s[i]-s[j])*s[j]

设DP[i][k]为将前i个节点分为k+1段的最小价值，即将第i条铁轨炸毁且前面总计炸了k条铁轨的最小价值

则设DP[i][k]=min(DP[j][k-1]+val[j,i])；

则这个状态转移方程一脸可以斜率优化的表情

那么就优化他好了

DP[j][k-1]+w[i]-w[j]-(s[i]-s[j])*s[j]<DP[k][k-1]+w[i]-w[k]-(s[i]-s[k])*s[k]

==>DP[j][k-1]-DP[k][k-1]-s[j]^2+s[k]^2-w[j]+w[k]<s[i]*(s[j]-s[k])

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int SIZEN=1005;
int a[SIZEN],s[SIZEN];
int w[SIZEN];
int q[SIZEN];
int dp[SIZEN][2];
int head,tail;
int getup(int k,int j,int m){
    return dp[j][m^1]-w[j]+s[j]*s[j]-(dp[k][m^1]-w[k]+s[k]*s[k]);
}
int getdown(int k,int j,int m){
    return s[j]-s[k];
}
void solve(int n,int m){
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
        s[i]=s[i-1]+a[i];
    for(int i=1;i<=n;i++)
        w[i]=w[i-1]+a[i]*s[i-1];
    for(int i=1;i<=n;i++)
        dp[i][0]=w[i];
    int cur=0;
    for(int j=1;j<=m;j++){
        head=tail=0;
        q[tail++]=0;
        cur^=1;
        for(int i=1;i<=n;i++){
            while(head+1<tail){
                int dy=getup(q[head],q[head+1],cur);
                int dx=getdown(q[head],q[head+1],cur);
                if(dy<s[i]*(s[q[head+1]]-s[q[head]])) head++;
                else break;
            }
            int k=q[head];
            dp[i][cur]=dp[k][cur^1]+(w[i]-w[k])-s[k]*(s[i]-s[k]);
            while(head+1<tail){
                int dy1=getup(q[tail-2],q[tail-1],cur);
                int dx1=getdown(q[tail-2],q[tail-1],cur);
                int dy2=getup(q[tail-1],i,cur);
                int dx2=getdown(q[tail-1],i,cur);
                if(dy1*dx2>=dy2*dx1) tail--;
                else break;
            }
            q[tail++]=i;
        }
    }
    printf("%d\n",dp[n][cur]);
}
int main()
{
    //freopen("data.in","r",stdin);
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
        solve(n,m);
}