hdu 4374 One hundred layer (dp +单调队列 2012 Multi-University Training Contest 8 )

acm.hdu.edu.cn/showproblem.php?pid=4374

 

题意： 有n层，每层有m个part。在一层中你只能向着一个方向移动（左或者右），最多能移动T步，

      经过每个部分是都能得到这个部分的分数。起始位置在x位置，从第一层到最顶层能得到最多的分数

题解：

dp + 单调队列 ；

对于 左边我们可以得到  dp[i][j] = max( dp[i - 1][k]  + sum（k， j）)       j - t <=k <= j；

我们的队列 要维护的 就是 

dp[i - 1][k]  + sum（k， j）

 由于 sum （k ,j） 单调队列要维护的状态必须是和 现在的状态 无关（或着说是 以知的），但 sum(k,j)  用到了现在的状态；

 

所以 我们要进行转换一下，   sum(k,j) = sum (1,j) - sum (1,k - 1);

所以 原式变为    

dp[i - 1][k]  + sum (1,j) - sum (1,k - 1)   = (dp[i - 1][k]   - sum(1,k)) + sum (1,j) 
而 dp[i -1][k] - sum(1,k - 1)  相对于 dp[i][j]  来说 是 以知的   所以    

dp[i -1][k] - sum(1,k - 1)      就是  我们 队列 要维护的状态

 

右边同理 可得

 

 

  1 #include<stdio.h>
  2 #include<iostream>
  3 #include<algorithm>
  4 #include<cstring>
  5 #include<cmath>
  6 #include<queue>
  7 #include< set>
  8 #include<list>
  9 #include<map>
 10  #define Min(a,b)  a>b?b:a
 11  #define Max(a,b)  a>b?a:b
 12  #define CL(a,num)  memset(a,num,sizeof(a));
 13  #define inf 99999999
 14  #define maxn    10010
 15  #define mod 100000007
 16  #define eps  1e-6
 17  #define ll  long long
 18  #define M   15520
 19  using  namespace std;
 20  int n,m,x,t;
 21  struct node
 22 {
 23      int x;
 24      int w;
 25     node( int xx, int yy): x(xx),w(yy){}
 26 };
 27  int f[ 110][maxn],sum[maxn] ,dp[ 110][maxn];
 28  int main()
 29 {
 30      // freopen("data.txt","r",stdin);
 31       int i ,j ;
 32      while(scanf( " %d%d%d%d ",&n,&m,&x,&t)!=EOF)
 33     {
 34         list<node>que;
 35          for(i =  0; i < n ;++i)
 36         {
 37              for(j =  1 ;j <= m; ++j)
 38             scanf( " %d ",&f[i][j]);
 39         }
 40 
 41          for(i =  0; i <= n;++i)
 42         {
 43              for( j =  0; j <= m ;++j)
 44             {
 45                 dp[i][j] = -inf ;
 46             }
 47         }
 48           int cnt = f[ 0][x];
 49          dp[ 0][x] = f[ 0][x] ;
 50          for(i =  0,j = x -  1; i < t&& j >= 1;i++,j--) // 往左处理
 51          {   cnt += f[ 0][j];
 52             dp[ 0][j] = cnt ;
 53         }
 54 
 55         cnt = f[ 0][x] ;
 56          for(i =  0,j = x +  1; i < t && j <= m;i++,j++)// 往右处理
 57         {
 58            cnt += f[ 0][j] ;
 59            dp[ 0][j] = cnt ;
 60 
 61 
 62         }
 63 
 64          for(i =  1; i < n;++i)
 65         {
 66             sum[ 0] =  0;
 67             que.clear() ; //   注意要清空  我就 WA 一次
 68               for(j =  1 ; j <= m ;++j)//左处理
 69             {
 70 
 71 
 72 
 73                 sum[j] = sum[j -  1] + f[i][j] ;
 74 
 75                  while(!que.empty() && que.front().x < j - t)   //距离 大于 t 了 要出队列
 76                    que.pop_front();
 77 
 78                     int  tmp = dp[i -  1][j] - sum[j -  1] ;
 79 
 80                  while(!que.empty() && que.back().w  <= tmp)
 81                      que.pop_back() ;
 82 
 83                  que.push_back(node(j,tmp));
 84                  if(!que.empty())
 85                     dp[i][j] =  sum[j] + que.front().w  ;
 86 
 87             }
 88 
 89 
 90 
 91 
 92 
 93             que.clear() ;
 94             sum[m +  1] =  0;
 95              for(j = m ; j >=  1 ;--j)//  右处理
 96             {
 97 
 98 
 99                 sum[j] = sum[j +  1] + f[i][j] ;
100 
101                  while(!que.empty() && que.front().x - j  > t)//距离 大于 t 了 要出队列
102                    que.pop_front();
103 
104                     int  tmp = dp[i -  1][j] - sum[j +  1] ;
105 
106                  while(!que.empty() && que.back().w  <= tmp)
107                      que.pop_back() ;
108 
109                  que.push_back(node(j,tmp));
110 
111                  if(!que.empty())
112                     dp[i][j] = max(dp[i][j],sum[j] + que.front().w );
113                     
114             }
115 
116 
117      }
118 
119         int ans = dp[n -  1][ 1];
120          for(i =  2;i <= m;++i)
121         {
122             ans = max(ans,dp[n -  1][i]);
123         }
124         printf( " %d\n ",ans);
125 
126 
127 
128     }
129 }