P3089 Pogo-Cow S

[USACO13NOV] Pogo-Cow S

题目传送门

题解

首先，一眼DP，想想怎么推状态转移方程

朴素DP

定义二维数组 \(f[i][j]\)，其中第一维表示当前所在的目标点是\(i\)，第二维表示上一个到达的目标点\(j\),即是由目标点\(j\)转移到目标点\(i\)，处于\(i\)点的最大得分

设\(k\)表示\(j\)的上一个目标点，易得方程：

\[f_{i,j}=max\{f_{i,j} ,f_{j,k}+p_i\}
\]

那么我们需要三层循环，分别枚举\(i,j,k\);

当然依照题意，我们需要两次DP，从左往右推和从右往左推，然后取最大值才是正确答案

就像我忘记推两遍所以多WA一次

如果你按照上面的方程打好了，提交，恭喜你TLE

单调队列优化DP

\(n\le 1000\)的限制使朴素DP被卡死，我们想办法用单调队列优化这个方程。单调队列通常用来维护单调性（多为递增或递减），在使用时只用到极值，但还是需要把每个元素进一次队列，因为题目中可能会有其他限制使当前最大值不符合要求，此时令最大值出队列，不断寻找符合条件的次大值。

题目中也有对于方程的限制条件：

每次跳跃的距离至少和上一次跳跃的距离相等，并且必须跳到一个目标点

可以得到方程的限制条件

\[f_{i,j}=max\{f_{i,j} ,f_{j,k}+p_i\}(x_i-x_j\ge x_j-x_k)
\]

改变这个方程，得到另一个方程

\[f_{i-1,j}=max\{f_{i-1,j},f_{j,k}+p_i \}(x_{i-1}-x_j\ge x_j-x_k)
\]

我们可以发现\(f_{i,j}\)可以由\(f_{i-1,j}\)转移过来，但限制条件有所不同，每次\(x_j\)是不变的，从\(f_{i-1,j}\)转移到\(f_{i,j}\)时，一定有\(x_i\ge x_{i-1}\)，因此\(k\)的取值也会改变，用单调队列维护\(k\)，得到符合要求的最大的\(f_{j,k}\)，代入方程

\[f_{i,j}=max\{f_{i-1,j}-p_{i-1}+p_i ,f_{j,k}+p_i \}(x_i-x_j\ge x_j-x_k)
\]

\[f_{i,j}=max\{f_{i-1,j}-p_{i-1},f_{j,k} \}+p_i(x_i-x_j\ge x_j-x_k)
\]

核心代码

for(int j=1;j<=n;j++){
    f1[j][j]=cow[j].p;//边界
    int k=j;
    for(int i=j+1;i<=n;i++){
        f1[i][j]=f1[i-1][j]-cow[i-1].p;
        int isaac=0;
        while(k>=1&&cow[i].x-cow[j].x>=cow[j].x-cow[k].x){
            isaac=Max(isaac,f1[j][k]);
            k--;
        }
        f1[i][j]=Max(f1[i][j],isaac);
        f1[i][j]+=cow[i].p;
        maxn=Max(maxn,f1[i][j]);
    }
}

观察上面的单调队列，好像并没有入队列的操作，其实\(k\)是从\(j\)开始维护的，相当于把从\(j\)到\(1\)的所有\(f_{j,k}\)都入了队列，且\(f_{i,j}\)是由\(f_{i-1,j}\)转移过来的，一定有\(f_{i,j}\ge f_{i-1,j}\)，只需枚举每一个符合条件的\(k\)找到极大值，再进行转移，又因为\(x_i\ge x_{i-1}\)，\(i\)的取值范围一定包含\(i-1\)的取值。

正确性

设\(i\)的取值范围左边界为\(k_i\) , \(i-1\)对应\(k_{i-1}\)

则\(f_{i-1,j}-p_{i-1}\)就是\(k_{i-1}\)到\(j\)的最大值，\(f_{i,j}\)直接使用\(f_{i-1,j}+p_{i-1}\),再枚举区间\([k_i,k_{i-1})\),从中取最大值进行转移，相当于直接使用$ [k_i,j]$区间最大值，保证算法正确。

时间复杂度 \(O(n^2)\)

每个元素最多出队列一次，复杂度是\(O(n)\)，总的复杂度就是\(O(n^2)\)

Code

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+100;
int n,f1[N][N],maxn,f2[N][N];
struct pogo{
    int x,p;
}cow[N];
bool cmp(pogo a,pogo b)
{
    return a.x<b.x;
}
inline int Max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&cow[i].x,&cow[i].p);
        maxn=Max(maxn,cow[i].p);
    }
    sort(cow+1,cow+n+1,cmp);
    for(int j=1;j<=n;j++){
        f1[j][j]=cow[j].p;
        int k=j;
        for(int i=j+1;i<=n;i++){
            f1[i][j]=f1[i-1][j]-cow[i-1].p;
            int isaac=0;
            while(k>=1&&cow[i].x-cow[j].x>=cow[j].x-cow[k].x){
                isaac=Max(isaac,f1[j][k]);
                k--;
            }
            f1[i][j]=Max(f1[i][j],isaac);
            f1[i][j]+=cow[i].p;
            maxn=Max(maxn,f1[i][j]);
        }
    }
    for(int j=n;j>=1;j--){
        f2[j][j]=cow[j].p;
        int k=j;
        for(int i=j-1;i>=1;i--){
            f2[i][j]=f2[i+1][j]-cow[i+1].p;
            int isaac=0;
            while(k<=n&&cow[j].x-cow[i].x>=cow[k].x-cow[j].x){
                isaac=Max(isaac,f2[j][k]);
                k++;
            }
            f2[i][j]=Max(f2[i][j],isaac);
            f2[i][j]+=cow[i].p;
            maxn=Max(maxn,f2[i][j]);
        }
    }
    printf("%d",maxn);
}