单调队列与DP

      以前以为单调队列只能求解区间最值的问题，没想到还能用于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;
}