单调队列与DP

最新推荐文章于 2023-11-06 10:11:51 发布

Interstellar_

最新推荐文章于 2023-11-06 10:11:51 发布

阅读量303

点赞数

分类专栏：动态规划

本文链接：https://blog.csdn.net/Interstellar_/article/details/54601445

版权

动态规划专栏收录该内容

20 篇文章 1 订阅

订阅专栏

本文介绍了如何使用单调队列优化动态规划问题，将高复杂度的算法转换为更高效的实现。通过举例说明了在解决区间最值问题和动态规划过程中单调队列的应用，包括股票交易收益最大化和背包问题等。

摘要由CSDN通过智能技术生成

以前以为单调队列只能求解区间最值的问题，没想到还能用于dp的优化，使循环的维度直接减去1维，将原先O（n³）复杂度的方程优化成O（n²）。最近几天刷了几道相关的题目，遂小小的总结一下以防以后忘掉。

首先，单调队列是一种单调递增或者单调递减的队列（如1、3、5、7、9是单调递增的队列）。对于单调队列的操作主要有三种：插入（从队尾插入一个新元素）、取最值（取队头的元素）、删除（从队头开始删除已经失效的元素）。由于操作较简单，一般采用一维数组的方式来存储队列，用head、tail分别表示队头和队尾。操作的代码如下（以单调递增队列为例，即队首为最小值）。

    int q[100];
    int head = 0, tail = 0, x;
    //插入
    while(head < tail && q[tail-1] > x) tail--;
    q[tail++] = x;
    //取值
    printf("%d\n", q[head]);

但是，单调队列不是对所有的状态方程都有效，只有形如dp[i] = max{f[k]}+g[i]或dp[i] = min{f[k]}+g[i]，其中（k < i && g[i]与k无关）的方程才能进行优化，优化对象为f[k]。

例如，方程dp[i] = max{dp[j]}+i+j，其中（0<=i < 100, 0 <= j < i）。变换方程式，得dp[i] = max{dp[j]+j}+i。当i=1时，j只可取0，即dp[1] = dp[0]+1+0；当i=n时，j可取0-（n-1）。即i每增加1，j的范围也增加1。当i=n时，向队列中加入元素(dp[n-1]+n-1)，这样每次取出的队头元素再加上i，即为dp[i]的值。代码如下

    dp[0] = 0;
    for(int i = 1; i <= 100; i++) {
       int x = dp[i-1] + (i-1);
       while(head < tail && q[tail-1] < x) tail--;
       q[tail++] = x;
       dp[i] = q[head]+i;
    }

下面是几个题目

1.https://vjudge.net/problem/UESTC-594

方程不难想到，用dp(i, j)表示第i个孩子身高为j时的最小花费。则转移如下。dp(i, j) = min{ dp(i-1, k) + C*abs(j-k) + (x[i]-j)²}，其中，x[i]为第i个孩子原来的高度。

当k<=j时，变换方程得dp(i,j) = min{dp(i-1,k)+C*k}+(x[i]-j)²。另f(i-1, k) = dp(i-1,k)+C*k，g(i, j) = (x[i]-j)²，则dp(i, j) = min{f(i-1, k)}+g(i, j)。这样就可以用单调队列优化了。

当k>j时，同理得之。

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 50000 + 5;
const int INF = 1e9 + 10;
int h[maxn];
int dp[50005][105];
int q[500];
int head, tail;
int cur, pre;
int main()
{
	int n, c;
	while(scanf("%d%d", &n, &c) == 2) {
		for(int i = 1; i <= n; i++) scanf("%d", &h[i]);
		
		for(int i = 0; i <= 100; i++) {
            if(i < h[1]) dp[1][i] = INF;
            else dp[1][i] = (i-h[1])*(i-h[1]);
		}
		
		for(int i = 2; i <= n; i++) {
            //当k<=j时
            head = tail = 0;
            for(int j = 0; j <= 100; j++) {
                dp[i][j] = INF;
                int now = dp[i-1][j] - c * j;
                while(head < tail && q[tail-1] > now) tail--;
                q[tail++] = now;
                if(j >= h[i])dp[i][j] = q[head] + c*j + (h[i]-j)*(h[i]-j);
            }
            
            //当k>=j时
            head = tail = 0;
            for(int j = 100; j >= 0; j--) {
                int now = dp[i-1][j] + c * j;
                while(head < tail && q[tail-1] > now) tail--;
                q[tail++] = now;
                if(j >= h[i]) dp[i][j] = min(dp[i][j], q[head] - c*j + (h[i]-j)*(h[i]-j));
            }
            
		}
		
		int mi = 1e9 + 10;
		for(int i = h[n]; i <= 100; i++) mi = min(mi, dp[n][i]);
		printf("%d\n", mi);
	}
	return 0;
}

2、HDU3401 https://vjudge.net/problem/HDU-3401

一个人知道了接下来T天的股市行情，问他T天后最多能赚多少钱。

第i天买一股的价格为APi，卖一股的价格为BPi；每天最多买ASi股，卖BSi股。手里最多持MaxP股。两次交易之间相差W+1天。最初有0股。

设dp(i, j)表示第i天持有j股时最多能赚的钱数。则这j股要么是原来就有，要么是通过购买得到，要么是通过卖掉多余的得到，由此得到以下方程。

不买时: dp[i][j] = dp[i-1][j]。

从第i-W-1天又买进一些: dp[i][j] = max( dp[i-W-1][k] - (j-k)*ASi )。

从第i-W-1天卖出一些： dp[i][j] = max( dp[i-W-1][k] +(k-j)*BSi )。

如同上面题目那样将方程式进行适当的变形即可。

但这个题有一个注意的地方，因为每天的买卖数量是有限制的，所以在取队头元素前应先把数量不合法的元素去掉。

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 2000 + 5;
const int INF = 1e8 + 10;

struct Node
{
    int pos, val;
    Node(int pos = 0, int f = 0) : pos(pos), val(f){}
};

int dp[maxn][maxn];
int BP[maxn], AP[maxn], AS[maxn], BS[maxn];
Node que[maxn*10];
int head, tail;

int main()
{
   int t;
   scanf("%d", &t);
   while(t--) {
       int T, MaxP, W;
       scanf("%d%d%d", &T, &MaxP, &W);
       for(int i = 1; i <= T; i++) scanf("%d%d%d%d", &AP[i], &BP[i], &AS[i], &BS[i]);
       for(int i = 0; i <= MaxP; i++) {
          if(i > AS[1]) dp[1][i] = -INF;
          else dp[1][i] = -AP[1]*i;
       }
       for(int i = 2; i <= T; i++) {
            
          for(int j = 0; j <= MaxP; j++)
             dp[i][j] = dp[i-1][j];
             
          if(i - W - 1 <= 0) {
              for(int j = 0; j <= AS[i]; j++)
                 dp[i][j] = max(dp[i][j], -AP[i]*j);
              continue;
          }
          
          int pre = i - W - 1;
          //买股票
          head = tail = 0;
          for(int j = 0; j <= MaxP; j++) {
             int now = dp[pre][j] + j * AP[i];
             while(head < tail && que[tail-1].val < now) tail--;
             que[tail++] = Node(j, now);
             while(head < tail && que[head].pos < j-AS[i]) head++; //去掉不合法的元素
             dp[i][j] = max(dp[i][j], que[head].val-AP[i]*j);
          }
          //卖股票
          head = tail = 0;
          for(int j = MaxP; j >= 0; j--) {
             int now = dp[pre][j] + j * BP[i];
             while(head < tail && que[tail-1].val < now) tail--;
             que[tail++] = Node(j, now);
             while(head < tail && que[head].pos > j + BS[i]) head++; //去掉不合法的元素
             dp[i][j] = max(dp[i][j], que[head].val-BP[i]*j);
          }
          
       }
       int ans = -INF;
       for(int i = 0; i <= MaxP; i++)
          ans = max(ans, dp[T][i]);
       printf("%d\n", ans);
   }
}

3、多重背包问题(HDU2191)

现有n种物品，每件体积为Vi，价值为Wi，数量为Ci，装入体积为m的背包中，求最大价值。

设第i件物品体积为V，则可按照余数，将当前体积分为V-1组（0,1,2，....，V-1）。

设d是任意一组。则dp[i][d+j*V] = max( dp[i-1][d+k*V] + (j-k)*W)。其中 j-Ci<=k<=j。第一个小于等于号是怎么来的呢。因为物品i有Ci件，设当前要算dp[i][d+j*V], 则单调队列最多要取dp[i-1][d+j*V], dp[i-1][d+(j-1)*V]...dp[i-1][d+(j-Ci)*V]中的最大值，所以单调队列队头元素的下标k应满足j-Ci >= k，否则这个元素应该出列。

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 200 + 5;
const int INF = 1e8 + 10;
int dp[maxn][maxn];
int head, tail;
int qa[maxn], qb[maxn];

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) {
        int n, m;
        scanf("%d%d", &m, &n);
        for(int i = 1; i <= n; i++) {
            int v, w, c;
            scanf("%d%d%d", &v, &w, &c);
            for(int d = 0; d < v; d++) {
               head = tail = 0;
               for(int j = 0; j <= (m-d)/v; j++) {
                  int now = dp[i-1][j*v+d] - j*w;
                  while(head < tail && qa[tail-1] < now) tail--;
                  qa[tail] = now;
                  qb[tail++] = j;
                  while(qb[head] + c < j) head++; //因为第i件物品只有c个，所以，单调队列的容量为c。对j来说，取的应该是dp[j],dp[j-V],...dp[j-c*V]这些中的最大值
                  dp[i][j*v+d] = qa[head] + j*w;
               }
            }
        }
		printf("%d\n", dp[n][m]);
    }
    return 0;
}