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 = 1 << 30;
typedef __int64 LL;
/*
dp[i][j]表示走到第i个横线，第j个竖线的最大值
dp[i][j] = max(dp[i-1][k] + sum[j-1] - sum[k-1])
单调队列优化维护队首最大值，
*/

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

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

        }
        for (int i = 1;i <= n;++i)
        {
            for (int j = 1;j <= m;++j)
            {
                scanf("%d", &b[i][j]);
                sum1[i][j] = b[i][j];
                sum2[i][j] = sum2[i][j - 1] + b[i][j];
            }
            for (int j = m;j >= 1;--j)
                sum1[i][j] += sum1[i][j + 1];
        }
        for (int i = n;i >= 1;--i)
        {
            head = tail = 0;
            for (int j = 1;j <= m + 1;++j)
            {
                while (head < tail && dp[i + 1][j] - pre[i][j - 1] >= dp[i + 1][q[tail - 1]] - pre[i][q[tail - 1] - 1])
                    tail--;
                q[tail++] = j;
                while (head<tail && sum2[i][j-1] - sum2[i][q[head]-1]>k)
                    head++;
                dp[i][j] = dp[i + 1][q[head]] + pre[i][j - 1] - pre[i][q[head]-1];
            }
            head = tail = 0;
            
            for (int j = m+1;j >= 1;--j)
            {
                while (head < tail&&dp[i + 1][j] - suf[i][j ] >= dp[i + 1][q[tail - 1]] - suf[i][q[tail - 1] ])
                    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 + 1][q[head]] + suf[i][j] - suf[i][q[head]]);
            }
        }
        int ans = 0;
        for (int j = 1;j <= m + 1;++j)
            ans = std::max(ans, dp[1][j]);
        printf("%d
", ans);
    }
    return 0;
}