算法提高之动态规划：单调队列优化dp

素位明哲

已于 2022-01-30 22:10:43 修改

阅读量1.1k

点赞数 1

分类专栏：算法提高文章标签：动态规划算法

于 2022-01-28 13:55:27 首次发布

本文链接：https://blog.csdn.net/qq_37448336/article/details/122730380

版权

算法提高专栏收录该内容

20 篇文章 1 订阅

订阅专栏

0、综述

滑动窗口的长度不一定是固定的，只要满足窗口的左右端点是递增的即可。
在这里插入图片描述

1、最大子序和

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 300010, INF = 1e9;

int n, m;
int s[N];
int q[N];

int main()
{
//本题的数据集是前缀和
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &s[i]), s[i] += s[i - 1];

    int res = -INF;
    //tt=0 表示涵盖了一个元素 s[0]
    int hh = 0, tt = 0;
	//枚举结尾元素 a[k]
    for (int i = 1; i <= n; i ++ )
    {
    //为什么是i-m  不是i-m+1
    //例如末尾元素下标是5，区间长度为2。则左端点是5-2+1=4
    //而求4，5的元素和 则需要 s[5]-s[3] 则不需要+1。
        if (q[hh] < i - m) hh ++ ;
    //为什么先更新最大值，再更新数据s[k] 
    //因为求的是前缀和，即使区间长度为1，也不需要纳入s[k],仅需要s[k-1]
    //若要更新后再求最大值可能出现s[k]-s[k]的情况 则先求res，再更新。
        res = max(res, s[i] - s[q[hh]]);
        while (hh <= tt && s[q[tt]] >= s[i]) tt -- ;
        q[ ++ tt] = i;
    }

    printf("%d\n", res);

    return 0;
}

2、修剪草坪

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
//e比较大
typedef long long LL;

const int N = 1e5 + 10;

int n, m;
LL s[N];
LL f[N];
int q[N];

LL g(int i)
{
    if (!i) return 0;
    return f[i - 1] - s[i];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%lld", &s[i]);
        s[i] += s[i - 1];
    }

    int hh = 0, tt = 0;
    //i枚举的是终点 
    for (int i = 1; i <= n; i ++ )
    {
    //需要找的是g[] [i - m, i - 1]中的最大值 
        if (q[hh] < i - m) hh ++ ;
        f[i] = max(f[i - 1], g(q[hh]) + s[i]);
        while (hh <= tt && g(q[tt]) <= g(i)) tt -- ;
        q[ ++ tt] = i;
    }

    printf("%lld\n", f[n]);

    return 0;
}

3、旅行问题（最大子序和扩展到环形）

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
	
using namespace std;

typedef long long LL;
//破环成链 需要扩展为2倍
const int N = 2e6 + 10;

int n;
//有料和距离
int oil[N], dist[N];
//前缀和
LL s[N];
//队列
int q[N];
bool ans[N];

//先顺时针做一遍，再逆时针做一遍

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d%d", &oil[i], &dist[i]);
        s[i] = s[i + n] = oil[i] - dist[i];
    }
    for (int i = 1; i <= n * 2; i ++ ) s[i] += s[i - 1];

    int hh = 0, tt = 0;
    //顺时针做
    q[0] = n * 2 + 1;
    //i是起点-1（左端点） i+n终点（右段点）
    //实际上起点位于1~n之间，n~2n是为了预处理数据，找出其中的最小值
    //s[j]-s[i](此处真正的起点坐标是i+1)
    for (int i = n * 2; i >= 0; i -- )
    {
        //由于i代表起点-1，则i+n表示终点
        //q[hh]>i+n 抛出头
        if (q[hh] > i + n) hh ++ ;
        //起点位于1~n之间 
        //i表示 起点减1 ，i<n时起点位于1~n之间
        //例如 起点坐标是n，则计算前缀和需要s[j]-s[n-1].
        if (i < n)
        {
            //i表示起点-1，i+1表示起点
            //i表示起点减1 则真正的起点为i+1
            if (s[i] <= s[q[hh]]) ans[i + 1] = true;
        }
        //为什么先判断ans，再更新。
        //此时的i是否加入单调队列更新ans[i+1]?
        //因为此处i表示起点-1  s[j]-s[i] j应该是从s[i+1]~s[i+n]中的min
        //则不需要更新，需要先判断ans
        while (hh <= tt && s[q[tt]] >= s[i]) tt -- ;
        q[ ++ tt] = i;
    }
    
    //逆时针做
    //oil[i]表示每一个站点的油料
    //dist表示顺时针从一个站点到下一个站点的距离
    //逆时针表示从本站点到上一个站点的距离是dist[i-1]
    //例如2号点到3号点的距离是dist[2]，而2号点到1号点的距离是dist[1]
    //特例：从n号点到1号点的距离dist[n],逆时针 从1号点到n哈点的距离dist[0]
    //dist[0]没有初值，但是在数值上与dist[n]一致
    dist[0] = dist[n];
    for (int i = 1; i <= n; i ++ ) s[i] = s[i + n] = oil[i] - dist[i - 1];
    for (int i = 1; i <= n * 2; i ++ ) s[i] += s[i - 1];
    
    //逆时针的时候 起点是在n+1~2n中 1~n中是为了预处理数据
    //终点在前，起点在后。s[i]-s[j],s[i]是定值，s[j]max
    hh = 0, tt = 0;
    q[0] = 0;
    for (int i = 1; i <= n * 2; i ++ )
    {
    //i是起点（右段点）i-n+1 是左端点（终点）i-n是左端点前一个位置
    //为前缀和做铺垫
        if (q[hh] < i - n) hh ++ ;
        //起点位于 n+1~2n
        if (i > n)
        {
            //为什么-n，因为数组长度多扩展了一倍
            if (s[i] >= s[q[hh]]) ans[i - n] = true;
        }
        //为什么i不纳入更新s[j] 
        //从全局公式来开 s[i]-s[j]  j的取值范围应该是从i-1~i-n
        //则i不应该纳入更新ans
        while (hh <= tt && s[q[tt]] <= s[i]) tt -- ;
        q[ ++ tt] = i;
    }

    for (int i = 1; i <= n; i ++ )
        if (ans[i]) puts("TAK");
        else puts("NIE");

    return 0;
}

4、烽火传递

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 2e5 + 10, INF = 1e9;

int n, m;
int w[N], q[N];
//f[i]
//1-i中不包含连续m个没有点火的烽火台，
//且点燃第i个烽火台的所有方案
int f[N];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    //f[0]=0
    int hh = 0, tt = 0;
    //f[i]  枚举当点燃第i个烽火台时，前m个烽火台 i-m到i-1个烽火台中
    //点燃哪一个可以使代价最小  此处枚举的时是燃第i个烽火台
    for (int i = 1; i <= n; i ++ )
    {
        //j<i,j>=i-m 则此处可以等于i-m
        if (q[hh] < i - m) hh ++ ;
        //点燃第i个烽火台的最小代价是点燃前f[i-m]到f[i-1]中一个烽火台最小代价
        //加上点燃第i个烽火台的代价
        f[i] = f[q[hh]] + w[i];
        //最小代价  单调递增 队头是最小值
        //为什么先对f[i]赋值,再更新？
        //因为此时求的是点燃f[i]的最小代价，
        //点燃f[i]的最小代价需要f[i-1]到f[i-m]点燃一个烽火台的最小代价
        //因此f[i]赋值后再继续更新。
        while (hh <= tt && f[q[tt]] >= f[i]) tt -- ;
        q[ ++ tt] = i;
    }

    int res = INF;
    //枚举点燃最后m个烽火台中的任何一个，看看点燃哪一个代价最小。
    for (int i = n - m + 1; i <= n; i ++ ) res = min(res, f[i]);

    printf("%d\n", res);

    return 0;
}

5、绿色通道(二分)

二分的本质是前一半满足这个性质，后一半不满足这个性质
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 50010, INF = 1e9;

int n, m;
int w[N];
//这里要求最长只能有k个连续的空格，
//因此需要在[i - k - 1, i - 1]中找最小值。
//f[i]表示写第i道题目，且前i道题目中最长空格数量
//不超过k的所有方案中的最小花费时间。
int f[N], q[N];

bool check(int k)
{
    f[0] = 0;
    int hh = 0, tt = 0;
    for (int i = 1; i <= n; i ++ )
    {
        if (hh <= tt && q[hh] < i - k - 1) hh ++ ;
        f[i] = f[q[hh]] + w[i];
        while (hh <= tt && f[q[tt]] >= f[i]) tt -- ;
        q[ ++ tt] = i;
    }

    int res = INF;
    for (int i = n - k; i <= n; i ++ ) res = min(res, f[i]);

    return res <= m;
}

int main()
{
    scanf("%d%d", &n, &m);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);

    int l = 0, r = n;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }

    printf("%d\n", r);

    return 0;
}

6、理想的正方形（滑动窗口扩展到2维）

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, INF = 1e9;
//k表示正方的边长 nm表示矩形的行和列
int n, m, k;
int w[N][N];
//行方向上的最大值和最小值
int row_min[N][N], row_max[N][N];
int q[N];
//tot 长度
void get_min(int a[], int b[], int tot)
{
    int hh = 0, tt = -1;
    for (int i = 1; i <= tot; i ++ )
    {
    //<=i-k  i-k+1~i
        if (hh <= tt && q[hh] <= i - k) hh ++ ;
        while (hh <= tt && a[q[tt]] >= a[i]) tt -- ;
        q[ ++ tt] = i;
   	//为什么先迭代单调队列 后更新数据
   	//因为a[i]需要加入其中
        b[i] = a[q[hh]];
    }
}

void get_max(int a[], int b[], int tot)
{
    int hh = 0, tt = -1;
    for (int i = 1; i <= tot; i ++ )
    {
        if (hh <= tt && q[hh] <= i - k) hh ++ ;
        while (hh <= tt && a[q[tt]] <= a[i]) tt -- ;
        q[ ++ tt] = i;
        b[i] = a[q[hh]];
    }
}



int main()
{
    scanf("%d%d%d", &n, &m, &k);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &w[i][j]);
	//预处理出每一行的最值
    for (int i = 1; i <= n; i ++ )
    {
    //w[][] w[i]是传入每一行的数值 
    //row_min[][]  row_min[]是存储长度为正方形大小（k）
    //中的最小值 将正方形中每一行的最值压缩到最右侧的结果
    //m是每一行的长度
        get_min(w[i], row_min[i], m);
        get_max(w[i], row_max[i], m);
    }
	//做完行之后，枚举每一列
    int res = INF;
    int a[N], b[N], c[N];
    for (int i = k; i <= m; i ++ )
    {
    //之前将正方形中的最值压缩到正方形的最右侧
    //现在将正方形的最有侧存到一个数组中
    //a是存放最右侧一列的数据 b是最小值 c是最大值
        for (int j = 1; j <= n; j ++ ) a[j] = row_min[j][i];
        get_min(a, b, n);

        for (int j = 1; j <= n; j ++ ) a[j] = row_max[j][i];
        get_max(a, c, n);

        for (int j = k; j <= n; j ++ ) res = min(res, c[j] - b[j]);
    }

    printf("%d\n", res);

    return 0;
}