[ACM]初识斜率优化DP

刚刚接触斜率优化DP，做了几道比较基础的题，算是稍微有些理解了。

斜率优化DP的资料很多，最经典的资料还是周源04年OI论文《浅谈数形结合思想在信息学竞赛中的应用》，初学可以看它，进阶的话可以再去看看杨哲的《凸完全单调性的一个加强与应用》，做题可以搜题解。

几点学习心得：

1.动态规划时间复杂度：阶段*状态*决策所需时间。阶段*状态一般可视为状态总数，一般状态总数是确定的，我们无法减少它的遍历。那么，斜率优化DP就是在决策前通过维护策略的单调性减少状态数，降低一次决策所需的时间，从而降低时间复杂度。单调性如何维护由如何决策而定。

2.斜率优化DP一般需要先写出容易想到的状态转移方程，然后列举2个子状态发现是否对后续状态有单调性。

3.斜率优化DP一般通过单调队列维护状态，数形结合有助于解题，一般维护状态的单调性就是在2维坐标系中维护下凸折线。

4.需要参与决策的状态才能够入队，否则不要加入队列，或延迟加入它。特别注意新加入状态斜率与队尾最后2个状态斜率相等的情况，舍取要看题意。

列3道基础斜率优化DP题：

1.HDU 3507 Print Article

#include<cstdio>
#define maxn 500005
typedef long long ll;
long long   dp[maxn];
ll sum[maxn];
struct str
{
    ll y,x;
};
str que[maxn];
int main()
{
    int n,m;
    dp[0]=sum[0]=0;
    while(~scanf("%d%d",&n,&m))
    {
        int head=0,tail=0;
        que[0].x=que[0].y=0;
        for(int i=1;i<=n;i++){scanf("%I64d",&sum[i]);sum[i]+=sum[i-1];}
        for(int i=1;i<=n;i++)
        {
            while(tail>head)
            {
                str h1=que[head],h2=que[head+1];
                if(h2.y-h1.y<2*(h2.x-h1.x)*sum[i])head++;
                else break;
            }
            dp[i]=que[head].y+sum[i]*sum[i]-2*que[head].x*sum[i]+m;
            str ns;ns.x=sum[i];ns.y=dp[i]+sum[i]*sum[i];
            while(tail>head)
            {
                str h1=que[tail],h2=que[tail-1];
                if((ns.y-h1.y)*(h1.x-h2.x)<=(h1.y-h2.y)*(ns.x-h1.x))tail--;
                else break;
            }
            que[++tail]=ns;
        }
        printf("%I64d\n",dp[n]);
    }
    return 0;
}

 

2.POJ 3709 K-Anonymous Sequence

#include<cstdio>
#include<cstring>
#include<iostream>
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
using namespace std;
#define maxn 500005
typedef long long ll;
int num[maxn];
ll sum[maxn],dp[maxn];
struct str
{
    int pos;
    ll x,y;
} que[maxn];
bool checkTail(int p1,int p2,ll tx,ll ty)
{
    return (ty-que[p2].y)*(que[p2].x-que[p1].x)
            <=(que[p2].y-que[p1].y)*(tx-que[p2].x);
}
bool checkHead(int p1,int p2,int pos)
{
    return que[p2].y-que[p1].y<pos*(que[p2].x-que[p1].x);
}
int main()
{
    //read;write;
    int cas,n,m;
    num[0]=sum[0]=0;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
            sum[i]=num[i]+sum[i-1];
        }
        for(int i=m;i<2*m;i++)dp[i]=sum[i]-i*num[1];
        int head=1,tail=0;
        que[++tail].x=num[1],que[tail].y=0,que[tail].pos=0;
        for(int i=2*m;i<=n;i++)
        {
            int t=i-m;
            ll tx=num[t+1],ty=dp[t]-sum[t]+t*num[t+1];
            while(tail>head&&checkTail(tail-1,tail,tx,ty))tail--;
            que[++tail].x=tx,que[tail].y=ty,que[tail].pos=t;
            while(tail>head&&checkHead(head,head+1,i))head++;
            int pos=que[head].pos;
            dp[i]=dp[pos]+sum[i]-sum[pos]-(ll)(i-pos)*num[pos+1];
        }
        printf("%I64d\n",dp[n]);
    }
    return 0;
}

 

3.UVALive 4726 Average

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define maxn 150000
char ss[maxn];
long long sum[maxn];
int que[maxn];
bool checkTail(int p1,int p2,int p3)
{
    return (sum[p3]-sum[p2])*(p2-p1)<=(sum[p2]-sum[p1])*(p3-p2);
}
bool checkHead(int p1,int p2,int p3)
{
    return (sum[p3]-sum[p2])*(p3-p1)>=(sum[p3]-sum[p1])*(p3-p2);
}
int checkAns(int s1,int e1,int s2,int e2)
{
    long long t1=(sum[e2]-sum[s2])*(e1-s1);
    long long t2=(sum[e1]-sum[s1])*(e2-s2);
    if(t1==t2)return 1;
    else if(t1>t2)return 2;
    return 0;
}
int main()
{
    sum[0]=0;
    int cas,n,m;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        scanf("%s",ss);
        for(int i=1;i<=n;i++)sum[i]=sum[i-1]+ss[i-1]-'0';
        int head=1,tail=0,left=1,right=m;
        for(int i=m;i<=n;i++)
        {
            int t=i-m;
            while(tail>head&&checkTail(que[tail-1],que[tail],t))tail--;
            que[++tail]=t;
            while(tail>head&&checkHead(que[head],que[head+1],i))head++;
            t=checkAns(left-1,right,que[head],i);
            if(t==1&&right-left>i-que[head]-1)left=que[head]+1,right=i;
            else if(t==2)left=que[head]+1,right=i;
        }
        cout<<left<<" "<<right<<endl;
    }
    return 0;
}

 

4[HNOI2008]玩具装箱toy

/**************************************************************
    Problem: 1010
    User: sdau20104686
    Language: C++
    Result: Accepted
    Time:344 ms
    Memory:2248 kb
****************************************************************/
 
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
#define maxn 50005
ll sum[maxn];
ll dp[maxn];
int que[maxn];
ll n,m;
bool checkHead(int i,int j,int k)
{
    ll tk=sum[k]+k,tj=sum[j]+j,ti=sum[i]+i;
    ll rk=dp[k]+tk*tk+2*m*tk;
    ll rj=dp[j]+tj*tj+2*m*tj;
    if((rk-rj)<2*ti*(tk-tj))return true;
    return false;
}
bool checkTail(int i,int j,int k)
{
    ll tk=sum[k]+k,tj=sum[j]+j,ti=sum[i]+i;
    ll rk=dp[k]+tk*tk+2*m*tk;
    ll rj=dp[j]+tj*tj+2*m*tj;
    ll ri=dp[i]+ti*ti+2*m*ti;
    if((ri-rk)*(tk-tj)<=(rk-rj)*(ti-tk))return true;
    return false;
}
int main()
{
    //read;
    while(~scanf("%I64d%I64d",&n,&m))
    {
        m++;
        sum[0]=0,dp[0]=0,que[0]=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%I64d",&sum[i]);
            sum[i]+=sum[i-1];
        }
        int head=0,tail=0;
        for(int i=1;i<=n;i++)
        {
            while(tail>head&&checkHead(i,que[head],que[head+1]))head++;
            ll t=(i-que[head]+sum[i]-sum[que[head]]-m);
            dp[i]=dp[que[head]]+t*t;
            while(tail>head&&checkTail(i,que[tail-1],que[tail]))tail--;
            que[++tail]=i;
        }
        printf("%lld\n",dp[n]);
    }
    return 0;
}