单调队列优化dp

DP单调队列优化
满足：
位置单调
多项式中的每一项只和j或者k有关 

 

 

1.D. 修剪草坪 - 单调队列优化dp和斜率优化dp - 比赛 - 衡中OI (hszxoj.com)

注意：入队元素1--n，往往要从0开始添加到n+1,以方便计算上1和n的情况

有负数求最大值，初始化dp方程负无穷

dp方程有多种列法，要懂得转换思路，

草坪（D），f[i][j]既可以表示到i牛已连续修建了j个牛的最值，也可以是到i牛不包含他的最值，第二种就方便列转移（第一一种应该也可以）

const int N=100000+10;
ll f[N],sum[N];
deque<int>t;
//f[i[j到i头奶牛，包括他自己已经连续了j头 奶牛的最大稀松率
//f[i表示不选i奶牛的最大效率
int main()
{
// freopen("exam.txt","r",stdin);
int n=re(),k=re();
ll ans=0;
_f(i,1,n)
scanf("%lld",&sum[i]),sum[i]+=sum[i-1];
_f(i,0,n+1)
{
while(!t.empty()&&t.front()<i-k-1)t.pop_front();
if(!t.empty())f[i]=max(f[i],f[t.front()]+sum[i-1]-sum[t.front()]);
while(!t.empty()&&f[t.back()]-sum[t.back()]<=f[i]-sum[i])t.pop_back();
t.push_back(i);
// chu("max%d:%lld\n",i,f[i]);
ans=max(ans,f[i]);
}
chu("%lld",ans);
return 0;
}

 

2.瑰丽华尔兹。

C. 瑰丽华尔兹 - 单调队列优化dp和斜率优化dp - 比赛 - 衡中OI (hszxoj.com)

坐标dp:f[i][j]到i j位置的最大移动距离

f[t][i][j]表示在第t时刻在第i行第j列所能获得的最长距离。 
转移方程：f[t][i][j]=max(f[t-1][i][j],f[t][i*][j*]+1)(i*,j*为上一个合理的位置) 
这样时间复杂度为O(TNM)，可以过50%,但对于100%TLE且MLE。
所以必须优化，首先把时间t换成区间k，
令f[k][i][j]表示在第k段滑行区间中在位置i，j所能获得最长距离
注意到在第k段时间内只能向某个方向最多走x步（x为区间长度），得到转移方程
f[k][i][j]=max(f[k-1][i][j],f[k][i*][j*]+dis(i,j,i*,j*))(i*,j*为上一个合理的位置)
这个做法的时间复杂度是O(kn^3)，会超时，需要进一步优化
用单调队列优化掉内层的一个n，就可以做到O(kn^2)，可以AC
单调队列优化，如果是向上走就应该从下往上更新，并且先把上一个状态dp[x][y]放进队列再更新dp[x][y]的最值
不然会加重复 

const int MAXN=200+10;
int n, m, sx, sy, K, ans, dp[MAXN][MAXN];
int dx[5] = {0, -1, 1, 0, 0}, dy[5] = {0, 0, 0, -1, 1};
struct node{int dp, pos;}q[MAXN]; //q为单调递减队列，要存位置信息用来计算共走了几步
char mape[MAXN][MAXN];
void work(int x, int y, int len, int d) //第k个区间的时长为len，方向为d，起点坐标x,y
{
int head = 1, tail = 0;
for(int i = 1; x >= 1 && x <= n && y >= 1 && y <= m; i++, x += dx[d], y += dy[d])
if(mape[x][y] == 'x') head = 1, tail = 0; //遇到障碍，清空队列
else
{
while(head <= tail && q[tail].dp + i - q[tail].pos < dp[x][y]) tail--;
q[++tail] = node{dp[x][y], i};//维护单调性，把上一个状态的dp[x][y]放进去
while(q[tail].pos - q[head].pos > len) head++; //删除不可能

dp[x][y] = q[head].dp + i - q[head].pos; //最优解是队首元素+移动距离
ans = max(ans, dp[x][y]); //记录结果

}
}
int main()
{
scanf("%d%d%d%d%d", &n, &m, &sx, &sy, &K);
for(int i = 1; i <= n; i++) scanf("%s", mape[i] + 1);
memset(dp, -0x3f, sizeof(dp));
dp[sx][sy] = 0; //初始化，只有初始位置是0，其他都是负无穷（表示不可可能）
for(int k = 1, s, t, d, len; k <= K; k++)
{
scanf("%d%d%d", &s, &t, &d);
len = t - s + 1;
if(d == 1) for(int i = 1; i <= m; i++) work(n, i, len, d);//循环每列（移动只会影响列）
if(d == 2) for(int i = 1; i <= m; i++) work(1, i, len, d);
if(d == 3) for(int i = 1; i <= n; i++) work(i, m, len, d);
if(d == 4) for(int i = 1; i <= n; i++) work(i, 1, len, d);
}
printf("%d", ans);
return 0;
}

3FIREWORK

一个节日将在一个镇的主街道上举行。 街道被分为n段，从左到右编号为1到n，每个相邻部分之间的距离为1。

节日里在主街道有m个烟花要放，第i（1≤i≤m）次烟花将在ti时在ai段燃放。 如果您在第i次发射时处于x（1≤x≤n），您将获得幸福值bi - | ai - x | （请注意，幸福价值可能是负值）

您可以以单位时间间隔移动长度为d个长度单位，但禁止离开主要街道。 此外，在初始时刻（时间等于1）你可以在街道的任意部分，并希望最大化从观看烟花获得的幸福总和。 找到最大的总幸福。

请注意，两个或多个烟花可以同时发射

输入格式

第一行包含三个整数n, m, d ()

接下来m行每行包含三个整数ai, bi, ti ()。第 i 行描述第 i 次烟花发射

确保满足条件ti≤ti + 1（1≤i<m）

输出格式

输出一个整数，表示观看所有烟花获得的最大幸福总和

 

A. Watching Fireworks is Fun - 【比赛】2022高考集训3 - 比赛 - 衡中OI (hszxoj.com)

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<string>
#include<cstdlib>
#include<ctime>
#include<algorithm>
#include<iomanip>
#include<bitset>
#include<map>
#include<queue>
#include<bitset>
#include<deque>
#include<vector>
#define _f(i,a,b)  for(register int i=a;i<=b;++i)

#define f_(i,a,b)  for(register int i=a;i>=b;--i)

#define ll long long

#define chu printf


using namespace std;
inline int re()
{
    int x = 0, f = 1;
    char ch = getchar();
    while(ch > '9' || ch < '0')
    {
        if(ch == '-')
        {
            f = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        x = (x << 1) + (x << 3) + (ch^48);
        ch = getchar();
    }
    return x * f;
}
const int WR=1001000;ll INF=1e18;
struct firework
{
    int a,b,t;
}fire[400];
ll tmp[160000],f[160000];
int n,m,d;
int l,r;
int que[160000];
int main()
{
    freopen("fire.in","r",stdin);
    freopen("fire.out","w",stdout);
    n=re(),m=re(),d=re();
    _f(i,1,m)
    {
        fire[i].a=re(),fire[i].b=re(),fire[i].t=re();
    }
    for(int i=1;i<=m;i++)//f[i][j]:i烟花在j时刻绽放最大幸福值
    {
        memcpy(tmp,f,sizeof(f));
        int k=1;//当前扩展到的位置 
        ll dis=(ll)(fire[i].t-fire[i-1].t)*d;
        l=1,r=0;//初始为空.....吗？ 
        for(int j=1;j<=n;j++)
        {
            while(k<=min((ll)n,j+dis))//最多拓展到的位置
            {
                while(l<=r&&tmp[que[r]]<=tmp[k])r--;//值递减，不然就没有必要要那个que[r]了，离的远还小 
                que[++r]=k;
                k++;
            }
            while(l<r&&j-que[l]>dis)l++;//必须剩下一个，但是是这么剩吗？？
             f[j]=tmp[que[l]]+fire[i].b-abs(fire[i].a-j);
        }
     } 
     ll maxans=-INF;
     _f(i,1,n)maxans=max(maxans,f[i]);
     chu("%lld",maxans);
    return 0;
}
/*

f[i][j]=max(f[i-1][k]+summ)
abs(j-k)<=d*(time(i)-time(i-1))
直接枚举k肯定会超时
考虑单调性问题
f[i]固定
在j不断变大的过程中，我肯定是从f[i-1]选择一个位置转移
假设posm,posn
如果posm<posn,f[i-1][posm]<=f[i-1][posn]
 posm一定没用，我就可以扔了
 所以
 枚举n时：维护单调递减的队列 
     拓展新的可能位置（往右边动了多少）
     维护队头合法性（dis能到达）
     对头就是最优解 
*/