决策单调性优化dp学习笔记

从例题开始

HDU3507

Solution

首先，状态设计十分显然: $d{p}_i$表示前$i$个数的答案。

状态转移也十分显然: $d{p}_i=d{p}_{l-1}+({\sum }_{j=l}^i{a}_j{)}^2+M$。

即使使用了前缀和来优化，时间复杂度也仍只有$O(n^2)$，无法接受。

---

定义$d{p}_i$的决策点为使得$d{p}_i$的值最小的$j$，珂以发现，当$i$的值变大的同时，$d{p}_i$的决策点竟然单调不减。

我们称这个性质为“决策单调性”。

这个状态转移具有决策单调性又有什么用呢？难道可以优化到$O(nlogn)$? 是的，我们可以这么优化：

定义一个数组$p$，$p_i$表示$d{p}_i$的决策点。当我们想要求出$d{p}_i$的时候，我们先根据$p_i$的值迅速转移得到$d{p}_i$；然后我们从末尾往前扫一遍这个数组$p$，如果对于一个$j$使得$p_j$作为决策点没有$i$作为决策点更优，那么就把这个$p_j$替换掉。根据决策拥有单调性，我们可以优化这个扫描$p$数组并尝试替换的步骤，直接大力二分，得到$x$及其之后的决策点是$i$更优，然后我们将$p$数组中$[x,n]$这段区间全部替换为$i$即可。

这里涉及到“二分+单点查询，与区间摊”，可以使用线段树来维护，时间复杂度$O(nlo{g}^{2}n)$。

---

能不能优化到$O(nlogn)$呢？

我们学习一下珂朵莉树的思想(这是体现珂朵莉可爱的时候啦 )，我们维护许多三元组。一个三元组为$(l,r,x)$，表示$p_l$到$p_r$目前的决策点是$x$。

每次我们：
①转移得到$d{p}_i$，这个步骤没有变化。

②去掉开头无用的三元组。
即，假设我们扫描到的$i$为$4$，而最左边的那个三元组是$(4,6,2)$，可以发现$“4”$在做完①中的转移后就没用了，那么我们就将这个三元组变成$(5,6,2)$。还有一种情况，就是这个三元组是$(4,4,1)$，这时整个三元组都没用了，直接去掉即可。

③去掉末尾无用的三元组。我们从末尾往前扫，假设目前扫描到的三元组的开头是$l$，而$l$作为决策点没有$i$作为决策点更优，那么我们就直接把这个三元组删掉。

为什么可以删呢？为什么我们只需要判断左端点就可以了呢? 因为，在看到$i$的这一时刻，所有三元组的第三个元素的值都不会达到$i$。即，对于一个三元组，如果对于三元组的一个$l$，$i$作为决策点更优，那么整个三元组的决策点一定会不小于$i$，而绝对不可能是任何小于$i$的数。原来的决策点可以作废了，这个区间删掉就好了。

④我们可能会出现这样一种情况:

$\lfloor$ 一个三元组表示的一段区间中，前面的一部分的决策点不变，后面的那一部分的决策点是$i$更优。 $\rceil$

对于这样子的区间，显然有且仅有一个。我们直接在这个区间里面二分一个$mid$，使得$mid$左边的所有$dp$值的决策点不变更优，$mid$及其右边的$dp$值的决策点变成$i$更优。根据决策的单调性，二分的正确性有了保障。

⑤插入一段三元组$(mid,n,i)$，即区间$[mid,n]$的决策点是$i$。

放几张图：

At first:

①根据第一个三元组的决策点转移
②去掉无用的

③从末尾往前扫，假设当前三元组的左端点是$l$，区间决策点为$pos$；而$i$作为决策点比$pos$更佳。对于这样的区间直接删掉。

④我们在当前三元组序列末尾的区间里面二分一个$mid$，使得$mid$左边的所有$dp$值的决策点不变更优，$mid$及其右边的$dp$值的决策点变成$i$更优。

⑤插入一段三元组$(mid,n,i)$，即区间$[mid,n]$的决策点是$i$。

时间复杂度$O(nlogn)$。

Code

#include <bits/stdc++.h>
#define int long long
using namespace std;

int n,m,l=1,r=1;
int a[500005],pre[500005],dp[500005];

struct DP_triples
{
    int l,r,pos;
}b[500005];

int cost(int l,int r)
{
    return dp[l]+(pre[r]-pre[l])*(pre[r]-pre[l])+m;
}

int Binary(int l,int r,int i,int j)//二分那个mid
{
    int p;
    while (l<=r)
    {
        int mid=(l+r)>>1;
        if (cost(i,mid)<=cost(j,mid))
        {
            p=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    return p;
}

inline int read()
{
    int s=0,w=1;
    char ch=getchar();
    
    while (ch<'0'||ch>'9')
    {
        if (ch=='-')  w=-w;
        ch=getchar(); 
    }
    while (ch>='0'&&ch<='9')
    {
        s=(s<<1)+(s<<3)+(ch^'0');
        ch=getchar();
    }
    return s*w;
}

signed main()
{
    while (~scanf("%lld%lld",&n,&m))
    {
        for (int i=1;i<=n;i++)  a[i]=read();
        for (int i=1;i<=n;i++)  pre[i]=pre[i-1]+a[i];
        
        l=1,r=1;
        b[l].l=1,b[l].r=n,b[l].pos=0;
        
        for (int i=1;i<=n;i++)
        {
            dp[i]=cost(b[l].pos,i);
            if (b[l].r==i)  l++;
            else b[l].l++;
            
            while (cost(b[r].pos,b[r].l)>=cost(i,b[r].l))  r--;
            if (l>r)
            {
                r++;
                b[r].l=i+1,b[r].r=n,b[r].pos=i;
            }
            else
            {
                int k;
                if (cost(b[r].pos,b[r].r)<=cost(i,b[r].r))  k=b[r].r+1;
                else k=Binary(b[r].l,b[r].r,i,b[r].pos);
                
                if (k<=n)
                {
                    b[r].r=k-1;
                    b[++r].l=k,b[r].r=n,b[r].pos=i;
                }
            }
        }
        cout<<dp[n]<<endl;
    }
    return 0;
}

注意事项(特别重要!)

回顾一下上面我们所说的几步走，里面的特判特别多。

①直接转移: 没啥特判。就算有特判，也与“决策单调性优化$dp$”本身无关。
②去掉开头无用的: 一定要注意两种情况: 左端点加$1$，与整个三元组都要删去。

if (b[l].r==i)  l++;
else b[l].l++;

③去掉末尾错误的: 如果把整个三元组序列删成空的了，一定要补上一个$(i+1,n,i)$并不再二分。

if (l>r)
{
	r++;
	b[r].l=i+1,b[r].r=n,b[r].pos=i;
}
else 二分

④二分: 特判一下整个区间的决策点都不变的情况

if (cost(b[r].pos,b[r].r)<=cost(i,b[r].r))  k=b[r].r+1;

⑤加入区间: 特判一下$mid$(即代码中的$k$)不小于$n$的情况。这种情况出现，当且仅当$i$不能成为后面任何区间的更优的决策点。

if (k<=n)
{
	b[r].r=k-1;
	b[++r].l=k,b[r].r=n,b[r].pos=i;
}

顺便发一句牢骚，这个东西为什么叫二分栈啊……

即:
①转移；
②改头；
③删尾；
④二分；
⑤插入。

②③④⑤步各有一个特判，请注意。

模板题

洛谷P1912: 诗人小G

练习题

洛谷P3515: Lightning Conductor

这题不是$dp$题，但是有决策单调性，是不是很有意思……