hdu 3401 单调队列优化DP

dp【i】【j】表示第i天之后拥有j个股票的最大利润

那么dp【i】【j】 = max{ dp【i-1】【j】, dp【i-W-1】【k】 - ( j - k ) * ap【i】, dp【i-W-1】【k】 - ( k - j ) * bp【i】 }

这里直接从i-w-1转化而来，并没有考虑之前的，原因是之前的会先转换到i-w-1

然后这里可以用单调队列来优化 k 的选取，本来k的选取的复杂度是O(n),但是优化之后可以降为O(1)

怎么优化呢？  

注意这里的  dp【i-W-1】k】 - ( j - k ) * ap【i】  与 j有关

所以先变形为  dp【i-w-1】【k】 +k * ap【i】 - j * ap【i】

单调队列里面保存的是最大的  dp【i-w-1】【k】 +k * ap【i】

然后就是标准的单调队列优化了

然后还要注意下初始话的问题

ＡＣ代码如下：

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

#define MAX 0x3f3f3f3f

int ap[2200], bp[2200];
int anum[2200], bnum[2200];
int N, Maxp, W;
int q[2200], pos[2200], head, tail;
int dp[2200][2200];

int main(){
    int T;
    cin >> T;
    while( T-- ){
        cin >> N >> Maxp >> W;
        for( int i = 1; i <= N; i++ ){
            cin >> ap[i] >> bp[i] >> anum[i] >> bnum[i];
        }
        for( int i = 0; i <= N; i++ ){
            for( int j = 0; j <= Maxp; j++ ){
                dp[i][j] = -MAX;
            }
        }
        for( int i = 1; i <= W + 1; i++ ){
            for( int j = 0; j <= anum[i] && j <= Maxp; j++ ){
                dp[i][j] = -j * ap[i];
            }
        }
        int r;
        for( int i = 1; i <= N; i++ ){
            for( int j = 0; j <= Maxp; j++ ){
                dp[i][j] = max( dp[i-1][j], dp[i][j] );
            }
            if( i <= W + 1 )    continue;
            r = i - W - 1;
            head = 0;
            tail = -1;
            for( int j = 0; j <= Maxp; j++ ){
                while( head <= tail && dp[r][j] + j * ap[i] > q[tail] ) tail--;
                tail++;
                q[tail] = dp[r][j] + j * ap[i];
                pos[tail] = j;
                while( head <= tail && j - pos[head] > anum[i] )    head++;
                dp[i][j] = max( dp[i][j], q[head] - j * ap[i] );
            }
            head = 0;
            tail = -1;
            for( int j = Maxp; j >= 0; j-- ){
                while( head <= tail && dp[r][j] + j * bp[i] > q[tail] ) tail--;
                tail++;
                q[tail] = dp[r][j] + j * bp[i];
                pos[tail] = j;
                while( head <= tail && pos[head] - j > bnum[i] )    head++;
                dp[i][j] = max( dp[i][j], q[head] - j * bp[i] );
            }
        }
        int ans = -MAX;
        for( int j = 0; j <= Maxp; j++ ){
            ans = max( ans, dp[N][j] );
        }
        cout << ans << endl;
    }
    return 0;
}