【hdu 4374】One Hundred Layer

【题目链接】

点击打开链接

【算法】

不难看出，这题可以用动态规划来解决

f[i][j]表示第i行第j列能够取得的最大分数

则如果向右走，状态转移方程为f[i][j]=max{f[i-1][k]+a[i][k]+a[i][k+1]+...+a[i][j]}（i-T<=k<=j)

如果向左走，则状态转移方程为f[i][j]=max{f[i-1][k]+a[i][k]+a[i][k-1]+...+a[i][j]}  (j<=k<=i+T)

用前缀和优化，s[i][j]表示第i行前j个数的和

则式子被简化为 ：

向右走 ： f[i][j] = max{f[i-1][k]+s[i][j]-s[i][k-1]} (i-T<=k<=j)

向左走 ： f[i][j] = max{f[i-1][k]+s[i][k]-s[i][j-1]} (j<=k<=i+T)

但是这样做还是会TLE，所以我们继续优化 ：

我们可以将第一个状态转移方程中s[i][j]提出，式子被写成f[i][j] = max{f[i-1][k]-s[i][k-1]}+s[i][j] (i-T<=k<=j)

将第二个状态转移方程中s[i][j-1]提出，式子被写成f[i][j] = max{f[i-1][k]+s[i][k]}+s[i][j-1] (j<=k<=i+T)

于是我们就可以用单调队列维护最值，时间复杂度 ： O（数据组数*N*M）

【代码】

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100
#define MAXM 10000

typedef long long LL;

struct info {
    LL x,val;
};
LL i,j,N,M,X,T,tmp,ans;
LL a[MAXN+][MAXM+],s[MAXN+][MAXM+],f[MAXN+][MAXM+];
deque<info> q;

template <typename T> inline void read(T &x) {
    LL f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
    for (; isdigit(c); c = getchar()) x = x *  + c - '';
    x *= f;
}
template <typename T> inline void write(T x) {
    if (x < ) { putchar('-'); x = -x; }
    if (x > ) write(x/);
    putchar(x%+'');
}
template <typename T> inline void writeln(T x) {
    write(x);
    puts("");
}

int main() {

    while (cin >> N >> M >> X >> T) {
        ans = -2e9;
        for (i = ; i <= N; i++) {
            for (j = ; j <= M; j++) {
                read(a[i][j]);
            }
        }

        for (i = ; i <= N; i++) {
            for (j = ; j <= M; j++) {
                s[i][j] = s[i][j-] + a[i][j];
            }
        }

        for (i = ; i <= N; i++) {
            for (j = ; j <= M; j++) {
                f[i][j] = -2e9;
            }
        }
        for (i = X; i >= X - T; i--) f[][i] = s[][X] - s[][i-];
        for (i = X; i <= X + T; i++) f[][i] = s[][i] - s[][X-];

        for (i = ; i <= N; i++) {
            q.clear();
            for (j = ; j <= M; j++) {
                while ((!q.empty()) && (j - q.front().x > T)) q.pop_front();
                tmp = f[i-][j] - s[i][j-];
                while ((!q.empty()) && (tmp >= q.back().val)) q.pop_back();
                q.push_back((info){j,tmp});
                f[i][j] = q.front().val + s[i][j];
            }
            q.clear();
            for (j = M; j >= ; j--) {
                while ((!q.empty()) && (q.front().x - j > T)) q.pop_front();
                tmp = f[i-][j] + s[i][j];
                while ((!q.empty()) && (tmp >= q.back().val)) q.pop_back();
                q.push_back((info){j,tmp});
                f[i][j] = max(f[i][j],q.front().val-s[i][j-]);
            }
        }
        for (i = ; i <= M; i++) ans = max(ans,f[N][i]);
        writeln(ans);
    }

    return ;

}