hdu 2829 Lawrence DP 四边形优化（斜率优化）+wps二分 模板

//斜率优化+WQS二分
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e3+5;
const ll inf=0x3f3f3f3f3f3f3f3f;
int n,k,lis[maxn],head,tail,w[maxn];
ll dp[maxn],a[maxn],sum[maxn];
ll get_up(int i,int j)
{
    return dp[j]-sum[j]+a[j]*a[j]-dp[i]+sum[i]-a[i]*a[i];
}
ll get_down(int i,int j)
{
    return a[j]-a[i];
}
void get_dp(int i,int j,ll num)
{
    dp[j]=dp[i]+sum[j]-sum[i]-a[i]*(a[j]-a[i])+num;
    w[j]=w[i]+1;
}
int judge(ll num)
{
    head=tail=0;
    lis[tail++]=0;
    for(int i=1;i<=n;i++)
    {
        while(head+1<tail&&get_up(lis[head],lis[head+1])<a[i]*get_down(lis[head],lis[head+1]))
            ++head;
        get_dp(lis[head],i,num);
        while(head+1<tail&&get_up(lis[tail-1],i)*get_down(lis[tail-2],lis[tail-1])<=get_down(lis[tail-1],i)*get_up(lis[tail-2],lis[tail-1]))
            --tail;
        lis[tail++]=i;
    }
    return w[n];
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF&&(n||k))
    {
        k++;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",a+i);
            a[i]+=a[i-1];
            sum[i]=sum[i-1]+a[i-1]*(a[i]-a[i-1]);
        }
        ll l=0,r=sum[n]*sum[n],ans=0;
        while(l<=r)
        {
            ll mid=l+r>>1;
            if(judge(mid)<=k)
            {
                r=mid-1;
                ans=dp[n]-mid*k;
            }
            else
                l=mid+1;
        }
        printf("%lld\n",ans);
    }
    return 0;
}
//四边形优化+WQS二分
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf=0x3f3f3f3f3f3f3f3f;
const int maxn=1e3+5;
ll s[maxn],f[maxn],sum[maxn];
int w[maxn],n,k;
struct node{int l,r,num;}lis[maxn];
inline ll cal(int j,int i)
{
    return f[j]+sum[i]-sum[j]-s[j]*(s[i]-s[j]);
}
inline bool check(int k1,int k2,int i)
{
    ll val1=cal(k1,i),val2=cal(k2,i);
    return val1!=val2?val2<val1:w[k2]<=w[k1];
}
inline int get_pos(int k1,int k2,int l,int r)
{
    while(l<r)
    {
        int mid=l+r>>1;
        if(check(k1,k2,mid))
            r=mid;
        else
            l=mid+1;
    }
    return l;
}
inline int judge(ll num_k)
{
    int head=0,tail=0;
    lis[tail++]=node{1,n,0};
    for(int i=1;i<=n;++i)
    {
        while(head+1<tail&&lis[head].r<i)
            ++head;
        f[i]=cal(lis[head].num,i)+num_k;
        w[i]=w[lis[head].num]+1;
        if(check(i,lis[tail-1].num,n))
            continue;
        while(head+1<tail&&check(lis[tail-1].num,i,lis[tail-1].l))
            --tail;
        lis[tail-1].r=get_pos(lis[tail-1].num,i,lis[tail-1].l,lis[tail-1].r+1)-1;
        lis[tail]=node{lis[tail-1].r+1,n,i};
        tail++;
    }
    return w[n];
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF&&(n||k))
    {
        k++;
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",s+i);
            s[i]+=s[i-1];
            sum[i]=sum[i-1]+s[i-1]*(s[i]-s[i-1]);
        }
        ll l=0,r=sum[n]*sum[n],ans=0;
        while(l<=r)
        {
            ll mid=l+r>>1;
            if(judge(mid)<=k)
            {
                r=mid-1;
                ans=f[n]-mid*k;
            }
            else
                l=mid+1;
        }
        printf("%lld\n",ans);
    }
    return 0;
}
//斜率优化
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e3+5;
const ll inf=0x3f3f3f3f3f3f3f3f;
int n,m,lis[maxn],head,tail;
ll dp[maxn][maxn],a[maxn],sum[maxn];
ll get_up(int k,int i,int j)
{
    return dp[j][k-1]-sum[j]+a[j]*a[j]-dp[i][k-1]+sum[i]-a[i]*a[i];
}
ll get_down(int k,int i,int j)
{
    return a[j]-a[i];
}
void get_dp(int k,int i,int j)
{
    dp[j][k]=dp[i][k-1]+sum[j]-sum[i]-a[i]*(a[j]-a[i]);
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",a+i);
            a[i]+=a[i-1];
            dp[i][0]=sum[i]=sum[i-1]+a[i-1]*(a[i]-a[i-1]);
        }
        for(int i=1;i<=m;i++)
        {
            head=tail=0;
            lis[tail++]=0;
            for(int j=1;j<=n;j++)
            {
                while(head+1<tail&&get_up(i,lis[head],lis[head+1])<a[j]*get_down(i,lis[head],lis[head+1]))
                    ++head;
                get_dp(i,lis[head],j);
                while(head+1<tail&&get_up(i,lis[tail-1],j)*get_down(i,lis[tail-2],lis[tail-1])<=get_down(i,lis[tail-1],j)*get_up(i,lis[tail-2],lis[tail-1]))
                    --tail;
                lis[tail++]=j;
            }
        }
        printf("%lld\n",dp[n][m]);
    }
    return 0;
}