hdu 3401 Trade(单调队列优化dp)

解题思路：首先我们可以得出的dp状态是，dp[i][j]表示第i天有j张股票，最多能持有多少钱，初始值dp[0][0] = 0 ， 其余都为-INF。那么我们可以得到一个时间复杂度为o(t*mxp*交易上限)的暴力转移方程，这样还是会超时。找单调性，对于买入股票（卖出跟买入差不多的），设上一次能转移过来的交易日为k（ if ( i <= w ) k = 0 ; else k =i-w-1 ;)，而j张股票的最优值是从i推过来的，那么j+1的最优值至少是从i推过来的，这个性质我是这样推出来的:

若dp[k][i] - (j-i) * x (x表示当天的买入单价)>dp[k][i-1] - (j-(i-1)) *ｘ，则dp[k][i] - (j+1-i) * x > dp[k][i-1] - (j+1-(i-1)) * x。这样就有单调性了，那么就可以用单调队列优化了。

#include  
#include  
#include  
using namespace std ;  
  
const int INF = -10000000 ;  
const int maxn = 2222 ;  
int w , t , mxp ;  
struct Deque {  
    int val[maxn] , pos[maxn] ;  
    int tail , star ;  
    void init () {  
        star = 1 , tail = 0 ;  
    }  
    int empty () {  
        return star > tail ;  
    }  
    void push ( int id , int v ) {  
        while ( !empty () && val[tail] < v ) tail -- ;  
        val[++tail] = v ;  
        pos[tail] = id ;  
    }  
    int get ( int p , int k , int flag ) {  
        if ( !flag ) {  
            while ( pos[star] < p - k ) star ++ ;  
            return pos[star] ;  
        }  
        else {  
            while ( pos[star] >





 p + k ) star ++ ;  
            return pos[star] ;  
        }  
    }  
} q ;  
  
int dp[maxn][maxn] ;  
int a[maxn] , b[maxn] , c[maxn] , d[maxn] ;  
  
int main () {  
    int cas ;  
    scanf ( "%d" , &cas ) ;  
    while ( cas -- ){  
        int i , j , k ;  
        scanf ( "%d%d%d" , &t , &mxp , &w ) ;  
        for ( i = 1 ; i <= t ; i ++ )  
            scanf ( "%d%d%d%d" , &a[i] , &b[i] , &c[i] , &d[i] ) ;  
        for ( i = 0 ; i <= t ; i ++ )  
            for ( j = 0 ; j <= mxp ; j ++ )  
                dp[i][j] = INF ;  
        dp[0][0] = 0 ;  
        for ( i = 1 ; i <= t ; i ++ ) {  
            for ( j = 0 ; j <= mxp ; j ++ )  
                dp[i][j] = dp[i-1][j] ;  
            q.init () ;  
            if ( i <= w ) k = 0 ;  
            else k = i - w - 1 ;  
            for ( j = 0 ; j <= mxp ; j ++ ) {  
                q.push ( j , dp[k][j] + j * a[i] ) ;  
                int id = q.get ( j , c[i] , 0 ) ;  
                dp[i][j] = max ( dp[i][j] , dp[k][id] - (j-id) * a[i] ) ;  
            }  
            q.init () ;  
            for ( j = mxp ; j >= 0 ; j -- ) {  
                q.push ( j , dp[k][j] + j * b[i] ) ;  
                int id = q.get ( j , d[i] , 1 ) ;  
                dp[i][j] = max ( dp[i][j] , dp[k][id] + (id-j) * b[i] ) ;  
            }  
        }  
        int ans = 0 ;  
        for ( i = 0 ; i <= mxp ; i ++ ) ans = max ( ans , dp[t][i] ) ;  
        printf ( "%d\n" , ans ) ;  
    }  
    return 0 ;  
}