POJ 3926 Parade（DP）

题意：在一个n * m个网格街道中，有横向街道和纵向街道，其中纵向街道没有值，横向街道有一个长度和人气值，现在国王要从网格最下面的街道走向最上面的街道，有以下要求：

1、只能往上不能往下走

2、可以横向走但是不能走过一个街道两次，既可以向东也可以向西走

3、在同一行中横向走过的街道的总距离不能超过K

输出人气最大的路径的人气总和

思路：很显然这是一个dp题，设dp[i][j]到达(i,j)这个点的人气最大值，那么到达(i,j)这个位置可以从东、西、南三个方向到达，从南边到来的很容易得出就是dp[i + 1][j]，剩下就是计算从东边和从西边走来的，先处理西边走来的（东边的一样），显然dp[i][j] = min{ dp[i][j], dp[i + 1][k] + valL[i][j] - valL[i][k - 1] } （其中k < j而且sumL[i][j] - sumL[i][k-1] <= K(题目给定的K)，sumL[i][j]表示从左边开始第一个点到达第j个点的总距离，valL[i][j]表示从左边开始第一个点到达第j个点的总人气值, 因为从第k个点能到达第j个点的话只能按照(i+1, k)北走再向右走的路线，所以是dp[i + 1][k]，而不是dp[i][k]，此时的dp[i][k]已经更新了），这样思路就转换为了刘汝佳训练指南上的单调队列优化dp的例题了。最后说一下,输入好恶心，得用字符串优化.....

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
typedef long long ll;
const int maxn = 1e2 + 10;
const int maxm = 1e4 + 10;
const ll INF = 1e15;
using namespace std;

int n, m, k, x;
int ql[maxm * 10], qr[maxm * 10];
ll sumL[maxm], valL[maxm];
ll sumR[maxm], valR[maxm];
ll dis[maxn][maxm], dp[2][maxm];
ll val[maxn][maxm];
char s[maxn * maxm];

void init() {
    for(int i = 0; i < n + 5; i++) {
        dis[i][0] = dis[i][m + 1] = 0;
        val[i][0] = val[i][m + 1] = 0;
    }
}

ll getint() {
    ll data = 0,u = 1;
    while(s[x] < '0' || s[x] > '9') x++;
    if (x && s[x - 1] == '-')  u = -1;
    while (s[x] >= '0' && s[x] <= '9') {
          data = data * 10 + s[x] - '0';
          x++;
    }
    return data * u;
}

int solve(int cal, int c) {
    while(cal) {
        sumL[0] = sumR[m + 2] = 0;
        valL[0] = valR[m + 2] = 0;
        ///处理好从南部走上来的
        for(int j = 1; j <= m + 1; j++) {
            int r = m + 2 - j;
            sumL[j] = sumL[j - 1] + dis[cal][j];
            valL[j] = valL[j - 1] + val[cal][j];
            sumR[r] = sumR[r + 1] + dis[cal][r];
            valR[r] = valR[r + 1] + val[cal][r];
            dp[c][j] = dp[c ^ 1][j];
        }
        int tail, real;
        ///处理从左边走来的
        tail = real = 0;
        ql[real++] = 1;
        for(int j = 2; j <= m + 1; j++) {
            while(tail < real && sumL[j - 1] - sumL[ql[tail] - 1] > k) tail++;
            if(real - tail > 0) {
                ll add = dp[c ^ 1][ql[tail]];
                add += valL[j - 1] - valL[ql[tail] - 1];
                dp[c][j] = max(dp[c][j], add);
            }
            ll new_val = dp[c ^ 1][j] - valL[j - 1];
            while(real > tail && new_val >= dp[c ^ 1][ql[real - 1]] - valL[ql[real - 1] - 1]) real--;
            ql[real++] = j;
        }

        ///处理从右边走来的
        tail = real = 0;
        qr[real++] = m + 1;
        for(int j = m; j >= 1; j--) {
            while(tail < real && sumR[j] - sumR[qr[tail]] > k) tail++;
            if(real - tail > 0) {
                ll add = dp[c ^ 1][qr[tail]];
                add += valR[j] - valR[qr[tail]];
                dp[c][j] = max(dp[c][j], add);
            }
            ll new_val = dp[c ^ 1][j] - valR[j];
            while(real > tail && new_val >= dp[c ^ 1][qr[real- 1]] - valR[qr[real - 1]]) real--;
            qr[real++] = j;
        }
        cal--; c = !c;
    }
    return !c;
}

int main()
{
    while (gets(s)) {
        x = 0; n = getint();
        m = getint(); k = getint();
        if (!n && !m && !k) break;
        init();
        for(int i = 1; i <= n + 1; i++) {
            gets(s); x = 0;
            for(int j = 1;j <= m; j++) {
                val[i][j] = getint();
            }
        }
        for(int i = 1;i <= n + 1; i++) {
            gets(s); x = 0;
            for(int j = 1; j <= m; j++) {
                dis[i][j] = getint();
            }
        }
        for(int j = 1; j <= m + 1; j++) dp[0][j] = 0;
        int d = solve(n + 1, 1);
        ll ans = -INF;
        for(int j = 1; j <= m + 1; j++) {
            ans = max(ans, dp[d][j]);
        }
        cout << ans << endl;
    }
    return 0;
}