hdu 3401 Trade //單調隊列+DP

這道題目還是很不錯的

首先，我們假定對于某一天的選擇是買或賣

那麼狀态轉移方程是

對于買

f[i][j] = max (f[i][j], f[r][k] -  (j - k) * ap[i])  1 <= r <= i - w -1 , max(0, j - as[i]) <= k < j 

對于賣

f[i][j] = max (f[i][j], f[r][k] +  (j - k) * ap[i])  1 <= r <= i - w -1 , min(maxp, j + bs[i]) >k > j

是以對于每個發f[i][j],要枚舉1到i-w-1這個範圍的值和K值

是以總的時間複雜度是0（maxp*maxp*T*T）

顯然時間複雜度不行

開始降維

首先對于狀态轉移方程，加入一個

f[i][j] = max(f[i][j],f[i-1][j])

這樣就可以保證對于f[i][j]，f[i-w-1][]就已經包含了前面所有的最好情況，不用再枚舉 1 <= r <= i - w -1這一範圍

時間複雜度便成為0（maxp*maxp*T）

還不行

太慢了，還得降維

觀察對于f[i][j]

對于他的買這一情況

f[i][j] = max(f[i][j], f[i-w-w][k])   max(0, j - as[i]) <= k < j 

使用單調隊列維護後面這一情況，那就對于1到MAXP這一範圍進行順序維護，對于賣的情況是反序維護

具體見代碼，現在的時間複雜度就已經降為了0(T*maxp)

#include <cstdio>
#include <cstring>
const int MAXN = 2000 + 123;
int ap[MAXN], bp[MAXN], as[MAXN], bs[MAXN];
int f[MAXN][MAXN];
struct node
{
    int num, val;
}q[MAXN];
inline int min(int x,int y)
{
    return x<y?x:y;
}
inline int max(int x,int y)
{
    return x>y?x:y;
}
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]);

        memset(f, 200, sizeof(f));
        for(int i = 1; i <= w + 1; i++)
            for(int j = 0; j <= min(as[i], maxp); j++)
            {
                f[i][j] = -ap[i] * j;
            }

        for(int i = 2; i <= t; i++)
        {
            for(int j = 0; j <= maxp; j++)  f[i][j] = max(f[i][j], f[i-1][j]);

            if(i < w + 2) continue;

            int head = 0, tail = -1;
            q[++tail].num = 0;
            q[tail].val = f[i - w - 1][0];

            for(int j = 1; j <= maxp; j++)
            {
                while(tail >= head && j - q[head].num > as[i]) head++;
                //可能全不滿足也是有可能的,不可能就保持初始化的0
                if(head <= tail) f[i][j] = max(f[i][j], q[head].val - (j - q[head].num) * ap[i]);

                while(tail >= head && q[tail].val + (q[tail].num - j) * ap[i] < f[i - w - 1][j]) tail--;
                q[++tail].num = j;
                q[tail].val = f[i- w - 1][j];
            }

            head = 0, tail = -1;
            q[++tail].num = maxp;
            q[tail].val = f[i - w - 1][maxp];

            for(int j = maxp - 1; j >= 0; j--)
            {
                while(tail >= head && q[head].num - j > bs[i])  head++;
                if(head <= tail)  f[i][j] = max(f[i][j], q[head].val + (q[head].num - j) * bp[i]);

                while(tail >= head && q[tail].val + (q[tail].num - j) * bp[i] < f[i - w - 1][j]) tail--;
                q[++tail].num = j;
                q[tail].val = f[i - w - 1][j];
            }
        }
        int rmax = 0;

        for(int i = 0; i <= maxp; i++)
        if(f[t][i] > rmax) rmax = f[t][i];
        printf("%d\n", rmax);
    }
    return 0;
}