1D/1D动态规划学习总结

前言：

自从发现1D/1D动态规划这个新的技能块后，每次看到这类题目都能口嗨成功，然后队友催我赶紧学。再者发现有好多优化方法，所以慢慢学，每天学一点，加上还要做一些奇奇怪怪的题目保持状态，也就差不多了。

第0天（1D/1D动态规划）

什么是1D/1D动态规划？
1D/1D动态规划是指形如 d p i = m a x { d p j + w ( i , j ) } dp_{i}=max\{ dp_{j}+w(i,j)\} dpi​=max{dpj​+w(i,j)}的动态规划，当然$max$也可以换成$min$。
据说长这样的$dp$一般都可以优化到$o(nlogn)$。
优化的思路就是在$j$的范围中，快速找到一个最优的转移点。
学习思路大概就是学习这个转移方程的不同类型，然后对于每种类型学习它的优化方法。
学习链接（多去走走，这样笔者偷完知识就不会愧疚了，博客里会加入自己的东西（也许））

第0.5天（前缀和优化）

有个前缀和优化，这个笔者默认会了，就不学了。不会的话请读者自行学习。

第1天（单调队列优化）

啊~新的力量！
今天是单调队列优化dp，当然，就当大家都会单调队列了。
实话说，学完感觉原来的$dp$式也有点不恰当，我们把$d{p}_j$也看作是$w(i,j)$中$j$的一部分运算，那式子其实就是 d p i = m a x { w ( i , j ) } dp_{i}=max\{ w(i,j)\} dpi​=max{w(i,j)}。
好了，进入今天的正题。
按照我们的学习思路，我们应该对于此类优化，有一个归纳的转移式子，那就有了。

转移方程

d p i = m a x { w ( j ) } dp_{i}=max\{ w(j)\} dpi​=max{w(j)}

说明

这个方程的意思就是$dp$的转移只和$j$有关。然后这个$j$呢，一般是一个区间范围，并且随着$i$的变大，$j$的范围区间是整体右移的。这样可以保证它能在转移过程中，用单调队列找到最优点。

思路：

说明中提到$j$的范围区间整体右移，我们设转移$d{p}_{i-1}$时$j$的范围区间是$[l_{i-1},r_{i-1}]$，转移$d{p}_i$时$j$的范围区间是$[l_i,r_i]$。那么我们$r$变大的时候，就把新的元素加入到单调队列右边（如果要加的话，在这之前还要把右边一些不要的元素拿走），然后答案在队列左边找到范围内的。当然，这都是单调队列的东西，就不细讲了。

实战例题

PTA-Little Bird

题意

$n$棵树，每棵树有一个高度$d_i$，小$H$在第$1$棵树上，要跳到第$n$棵树上。在第$i$棵树上时，可以跳到第$i,i+1,\dots ,i+k$棵树上。每跳一次，如果高度不小于原来的高度，疲劳值就会加$1$。现在问小$H$从第$1$棵树上跳到第$n$棵树上，最少的疲劳值是多少。
$(1\le n\le k\le 10^6)$

思路

我们设状态$d{p}_i$表示跳到第$i$棵树上需要花费的最少疲劳值。
那么有转移方程 d p i = m i n { d p j + [ d i > = d j ] } dp_{i}=min\{dp_{j}+[d_{i}>=d_{j}]\} dpi​=min{dpj​+[di​>=dj​]}，其中$j\in [i-k,i-1]$。

我们要学习这个思路。
首先我们观察$j\in [i-k,i-1]$，我们发现区间随着$i$变大整体右移，成立。
然后$d{p}_j+[d_i>d_j]$，它是一个关于$i$和$j$的式子，呃好像不成立。
这时候只能发挥我们的聪明才智了，咳咳。
我们先发现$d{p}_i$单调不下降，且每次增加都是加$1$。所以对于两个$d{p}_j$的值，我们肯定直接取小的那个，因为小的那个$+1$也不会超过大的。然后对于两个相同的$d{p}_j$,我们一定优先取$d_j$大的那个，也就是要在范围内找使得$(-d{p}_j,d_j)$最大的$j$。这样就可以用单调队列优化了。

刚才演示翻车了，我决定用$d{p}_i=w(i,j),whereg(j)ismaxforjinrange$来作为新式子。

这样也许就可以泛化模型了。

代码

题目有点卡，开o2优化就过了。
写完下班。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

int q[1000005],fr,bk;
int d[1000005];
int dp[1000005];
int w(int i,int j)
{
    return dp[j]+(d[i]>=d[j]);
}
P g(int j)
{
    return P(-dp[j],d[j]);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&d[i]);
    int m;
    scanf("%d",&m);
    while(m--)
    {
        fr=bk=0;
        int k;
        scanf("%d",&k);
        dp[1]=0;
        q[bk++]=1;
        for(int i=2;i<=n;i++)
        {
            while(q[fr]<i-k)fr++;
            dp[i]=w(i,q[fr]);
            while(!(fr==bk)&&g(q[bk-1])<=g(i))bk--;
            q[bk++]=i;
        }
        printf("%d\n",dp[n]);
    }
	return 0;
}

第二天（分治优化）

（待续。。）
(upd:更新了标题后面不应该加冒号的bug)
昨天是关于$j$独立的转移，依据$j$的单调性用单调队列优化。
那么今天这个是不关于$j$独立，即和$i$和$j$都有关的，刚学了一种分治优化，当然你得先会分治。

转移方程

$d{p}_i=max(w(i,j)),j\in [1,i-1]$
又或者说$d{p}_i=w(i,j),whereg(i,j)ismaxforjinrange$
并且还需要它的转移，随着$i$满足某种决策单调性。

说明

总之，我们需要找的最优转移点和$i,j$都有关。
然后，转移要随着$i$满足决策单调性。举个例子，大致意思是，当$i$ 慢慢变大，最优决策点$j$也会慢慢变大。但这不意味着$j$大更优，有些$j$压根不会被作为最优决策点，只是哪些对每个$i$作为最优决策点的$j$们是随着$i$变大而变大的（不下降）。

思路

分治的大致做法是，我们先找中间的$d{p}_{mid}$的转移点$qmid$。然后根据决策单调性，当$i<mid$时，转移点$j\in [1,qmid]$；当$i>mid$时，转移点$j\in [qmid,n]$且$j<i$。
然后每次这样取中点求最优转移点，把区间割成两个一半。递归深度是$log$级的，那我们找转移点就暴力遍历可能存在最优转移点的决策区间。总体复杂度$o(nlogn)$。

实战例题

Lightning Conductor

题意

给定一个长度为$n$的序列 { a n } \{a_{n}\} {an​}，对于每个 $i\in [1,n]$，求出一个最小的非负整数$p$，使得 $\forall j\in [1,n]$，都有 $a_j\le a_i+p-\sqrt{|i-j|}$
$1\le n\le 5\times 10^5,0\le a_i\le 10^9$

思路

我们令$d{p}_i$表示第$i$个答案。
首先，把绝对值处理掉，我们可以正向跑一遍$dp$，再逆向跑一遍，求个最大值。
那么正向的转移方程就是 d p i = m a x { a j − a i + i − j } , j ∈ [ 1 , i − 1 ] dp_{i}=max\{a_{j}-a_{i}+\sqrt{i-j}\},j\in [1,i-1] dpi​=max{aj​−ai​+i−j ​},j∈[1,i−1]。
关于$i$常量先提出来，变成 d p i = m a x { a j + i − j } − a i , j ∈ [ 1 , i − 1 ] dp_{i}=max\{a_{j}+\sqrt{i-j}\}-a_{i},j\in [1,i-1] dpi​=max{aj​+i−j ​}−ai​,j∈[1,i−1]。
那么现在变成了，我们所说的模范转移式 d p i = m a x { w ( i , j ) } dp_{i}=max\{w(i,j)\} dpi​=max{w(i,j)}，其中$w(i,j)=a_i+\sqrt{i-j}$。
然后，它要满足我们所说的决策单调性，即$i$变大的时候，我们选取的最优决策点$j$也会慢慢变大。我们观察式子$w_j(i)=a_i+\sqrt{i-j}$是一个关于$i$的函数，有$i-1$个这样的函数，我们要对于每个$i$
选取一个最佳的函数$w_j$，使得函数值最高。
然后我们发现这些函数的增长速度都是慢慢变慢的，且$w_j$比$w_{j+1}$在$i$相同时增长速度要慢。也就是一旦$i$增长到某个时候$w_j$被一个$w_k$超过了，且$k>j$，那么$w_j$将永无翻身之日。
总的来说，就是满足当$i$变大，最优决策点只会不断变大（或者换个题变小）。
满足我们前面所说的性质，然后就可以分治搞了。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

double a[500005];
ll dp1[500005],dp2[500005];
double w(int i,int j)
{
    return a[j]+sqrt(abs(i-j))-a[i];
}
void solve(int l,int r,int ql,int qr,ll *dp)
{
    if(l>r||ql>qr)return ;
    int mid=(l+r)/2;
    int qmid=ql;
    for(int i=ql;i<=qr&&i<mid;i++)if(w(mid,i)>w(mid,qmid))qmid=i;
    dp[mid]=ceil(w(mid,qmid));
    solve(l,mid-1,ql,qmid,dp);solve(mid+1,r,qmid,qr,dp);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lf",&a[i]);
    solve(1,n,1,n,dp1);
    reverse(a+1,a+n+1);
    solve(1,n,1,n,dp2);
    reverse(dp2+1,dp2+n+1);
    for(int i=1;i<=n;i++)printf("%lld\n",max(0ll,max(dp1[i],dp2[i])));
	return 0;
}

第N天

（待续。。）
拿金了，先断更了