动态规划(DP) 之优先队列优化 HDOJ 3401Trade

HDOJ 3401题目连接

 

 

告诉你 T 天里,物品的买卖价格,和当天最多买卖数量,还有 T 天里最多保存物品数量,每一次买卖间隔时间必须大于 w+1

 

很容易想到DP【i】【j】表示,第i天结束的时候还保存有j个物品时的最大获利

 

初始化dp【i】【j】 = dp【i-1】【j】;

那么状态方程dp【i】【j】 = MAX(dp【k】【j】),其中k<= i – w – 1;

且有                 dp【i】【j】=MAX(dp【k】【z】 – (j – z) * buyValue【i】),其中,k<=i-w-1,z<j且 z>=j-maxBuy【i】;

还有                 dp【i】【j】=MAX(dp【k】【z】 + (z – j) * sellValue【i】),其中,k<=i-w-1,z>j且 z<=j  +  maxSell【i】;

 

所以会有i,j,z三层循环,而他们的范围都是2000,所以有2000^3的复杂度,肯定超时

 

这个时候我们可以用优先队列来优化,使之少一层循环

 

z<j且 z>=j-maxBuy【i】的时候,dp【i】【j】= dp【k】【z】 – (j – z) * buyValue【i】= dp【k】【z】 + z  * buyValue【i】 –  j*buyValue【i】

 

可以发现dp【k】【z】 + z  * buyValue【i】部分只与z有关;

– j*buyValue【i】而后面的部分只与j有关,所有z都一样;

 

所以我们需要的是式子前面这一部分的值越大越好,而z的范围又随着j的变化而变化,刚好是优先队列的使用情况

 

 

这个题目有注意的地方

(1)就是k可以定为i-w-1,因为i-w-1之前的所有并没有比i-w-1优,相反i-w-1这一天有可能比前面的优

(2)别忘了i可以从i-1天来

(3)最后的答案其实一定是剩余0个物品的时候

 

我的代码:

#include<stdio.h>
//#include<string.h>
//#include<algorithm>
#define CANNOT (-0x3fffffff)

#define MAX 2100

int dp[MAX][MAX];
int days[MAX][4];

int que[MAX], tail, front;
int where[MAX];

int t, maxp, w;

int Max(int a, int b)
{
 return a > b ? a : b;
}

int main()
{
 int i, j;
 int cases;
 int result;
 int xx;
 scanf(“%d”, &cases);
 while(cases –)
 {
  result = 0;
  scanf(“%d%d%d”, &t, &maxp, &w);
  for(i = 1; i <= t; i ++)
  {
   scanf(“%d%d%d%d”, &days[i][0], &days[i][1], &days[i][2], &days[i][3]);
  }
  for(i = 1; i <= t; i ++)
  {
   if(i <= w + 1)
   {
    for(j = 0; j <= maxp; j ++)
    {
     if(j <= days[i][2])
     {
      dp[i][j] = -j * days[i][0];
     }
     else
     {
      dp[i][j] = CANNOT;
     }
     if(i > 1)
      dp[i][j] = Max(dp[i][j], dp[i – 1][j]);
    }
   }
   else
   {
    for(j = 0; j <= maxp; j ++)
    { 
     dp[i][j] = dp[i – w – 1][j];
     dp[i][j] = Max(dp[i][j], dp[i – 1][j]);
    }
    tail = -1;
    front = 0;
    int temp = 0;
    for(j = 0; j <= maxp; j ++)
    {
     while(temp < j)
     {
      if(dp[i – w – 1][temp] == CANNOT)
      {
       temp ++;
       continue;
      }
      xx = dp[i – w – 1][temp] + temp * days[i][0];
      while(front <= tail)
      {
       if(xx >= que[tail])
        tail –;
       else
        break;
      }
      que[++ tail] = xx;
      where[tail] = temp;
      temp ++;
     }
     while(front <= tail && j – where[front] > days[i][2])
     {
      front ++;
     }
     if(front <= tail)
     dp[i][j] = Max(dp[i][j], que[front] – j * days[i][0]);
    }

    tail = -1;
    front = 0;
    temp = 0;
    for(j = 0; j <= maxp; j ++)
    {
     while(temp <= j + days[i][3] && temp <= maxp)
     {
      if(dp[i – w – 1][temp] == CANNOT || temp <= j)
      {
       temp ++;
       continue;
      }
      xx = dp[i – w – 1][temp] + temp * days[i][1];
      while(front <= tail)
      {
       if(xx >= que[tail])
        tail –;
       else
        break;
      }
      que[++ tail] = xx;
      where[tail] = temp;
      temp ++;
     }
     while(front <= tail && where[front] <= j)
     {
      front ++;
     }
     if(front <= tail)
     dp[i][j] = Max(dp[i][j], que[front] – j * days[i][1]);
    }
   }
  }
 // result = 0;
 // for(i = 0; i <= maxp; i ++)
 //  result = Max(result, dp[t][i]);
 // printf(“%d\n”, result);
  printf(“%d\n”, dp[t][0]);
 }
 return 0;
}

 

点赞