Codeforces1304F.Animal Observation

分析一下得知是DP问题，时间复杂度符合，设dp[i][j]为从第i天开始，第j个位置能得到的最大值，其有三种转移状态

1.与上一天的选择有重合

2.与上一天的选择没有重合，且上一天的选择在左边

3.与上一天的选择没有重合，且上一天的选择在右边

那么得到转移方程，

1.dp[i][j] = max(dp[i-1][x])(x+k-1与j+k-1有交点)-重复部分

2.dp[i][j] = max(dp[i-1][x])(x+k-1在j的左边)+该次选择得到的数

3.同2

我们预处理前缀和，再在每次dp更新后为下一天的dp更新每个点左边的最大值，复杂度为O(nmk)

#include<bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
typedef long long LL;

const int maxn = ;
const int maxm = 2e4+;

int dp[maxn][maxm], C[maxn][maxm], lmax[maxn][maxm], rmax[maxn][maxm];

int getsum(int i, int p1, int p2) {
    return C[i][p2] - C[i][p1-];
}

void run_case() {
    int n, m, k, val;
    cin >> n >> m >> k;
    for(int i = ; i <= n; ++i)
        for(int j = ; j <= m; ++j) {
            cin >> val;
            C[i][j] = C[i][j-] + val;
        }
    for(int i = ; i <= n; ++i) {
        for(int j = ; j <= m - k + ; ++j) {
            val = getsum(i, j, j+k-) + getsum(i+, j, j+k-);
            if(i == ) {
                dp[i][j] = val;
                continue;
            }
            int mx = ;
            // intersect part
            for(int l = max(, j-k+); l <= min(m-k+, j+k-); ++l)
                mx = max(mx, dp[i-][l]+val-getsum(i, max(l, j), min(j+k-,l+k-)));
            dp[i][j] = mx;
            if(j > k) dp[i][j] = max(dp[i][j], lmax[i-][j-k]+val);
            if(j + k <= m - k + ) dp[i][j] = max(dp[i][j], rmax[i-][j+k]+val);
        }
        for(int j = ; j <= m-k+; ++j) lmax[i][j] = max(dp[i][j], lmax[i][j-]);
        for(int j = m-k+; j >= ; --j) rmax[i][j] = max(dp[i][j], rmax[i][j+]);
    }
    cout << *max_element(dp[n]+, dp[n]++m) << "\n";
}

int main() {
    ios::sync_with_stdio(false), cin.tie();
    //cout.setf(ios_base::showpoint);cout.precision(10);
    //int t; cin >> t;
    //while(t--)
    run_case();
    cout.flush();
    return ;
}

hard vision就是将k的范围扩大很多，可以用线段树O(nmlogm)或者是单调队列O(nm)来优化区间最值问题，以后再补