uvalive4327（单调队列优化）

这题我有闪过是用单调队列优化的想法，也想过有左右两边各烧一遍。 但是不敢确定，搜了题解，发现真的是用单调队列，然后写了好久，调了好久下标应该怎么变化才过的。

dp[i][j] 表示走到第i行，第j个竖线的最大价值。

dp[i][j] = max(dp[i-1][k]+pre[i][j-1]-pre[i][k-1]);  从左往右

dp[i][j] = max(dp[i][j],dp[i-1][k]+suf[i][j]-suf[i][k]); 从右往左

 #pragma warning(disable:4996)
 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <math.h>
 #include <map>
 #include <set>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <bitset>
 #include <algorithm>
 #include <iostream>
 #include <string>
 #include <functional>
 const int INF =  << ;
 typedef __int64 LL;
 /*
 dp[i][j]表示走到第i个横线，第j个竖线的最大值
 dp[i][j] = max(dp[i-1][k] + sum[j-1] - sum[k-1])
 单调队列优化维护队首最大值，
 */

 int q[], head, tail;
 int dp[][];
 int a[][];
 int b[][];
 int pre[][], suf[][];
 int sum1[][];
 int sum2[][];
 int main()
 {
     int n, m, k;

     while (scanf("%d%d%d", &n, &m, &k),n+m+k)
     {
         memset(dp, , sizeof(dp));
         memset(pre, , sizeof(pre));
         memset(suf, , sizeof(suf));
         memset(sum1, , sizeof(sum1));
         memset(sum2, , sizeof(sum2));
         n++;
         for (int i = ;i <= n;++i)
         {
             for (int j = ;j <= m;++j)
             {
                 scanf("%d", &a[i][j]);
                 pre[i][j] = pre[i][j - ] + a[i][j];
                 suf[i][j] = a[i][j];
             }
             for (int j = m;j >= ;--j)
                 suf[i][j] += suf[i][j + ];

         }
         for (int i = ;i <= n;++i)
         {
             for (int j = ;j <= m;++j)
             {
                 scanf("%d", &b[i][j]);
                 sum1[i][j] = b[i][j];
                 sum2[i][j] = sum2[i][j - ] + b[i][j];
             }
             for (int j = m;j >= ;--j)
                 sum1[i][j] += sum1[i][j + ];
         }
         for (int i = n;i >= ;--i)
         {
             head = tail = ;
             for (int j = ;j <= m + ;++j)
             {
                 while (head < tail && dp[i + ][j] - pre[i][j - ] >= dp[i + ][q[tail - ]] - pre[i][q[tail - ] - ])
                     tail--;
                 q[tail++] = j;
                 while (head<tail && sum2[i][j-] - sum2[i][q[head]-]>k)
                     head++;
                 dp[i][j] = dp[i + ][q[head]] + pre[i][j - ] - pre[i][q[head]-];
             }
             head = tail = ;

             for (int j = m+;j >= ;--j)
             {
                 while (head < tail&&dp[i + ][j] - suf[i][j ] >= dp[i + ][q[tail - ]] - suf[i][q[tail - ] ])
                     tail--;
                 q[tail++] = j;
                 while (head<tail&&sum1[i][j] - sum1[i][q[head]]>k)
                     head++;
                 dp[i][j] =std::max(dp[i][j], dp[i + ][q[head]] + suf[i][j] - suf[i][q[head]]);
             }
         }
         int ans = ;
         for (int j = ;j <= m + ;++j)
             ans = std::max(ans, dp[][j]);
         printf("%d\n", ans);
     }
     return ;
 }