FZU 2250 不可能弹幕结界(单调队列优化dp)

/*
记录从上往下走不经过穿越能到达每一列j的行数i，用vector L[j]存下i
dp[i][j] 代表能否到达(i,j)这个位置，显然dp[i-1][j]成立的时候dp[i][j]
一定成立，然后看经过左走右走k步之内能否到达，他要么一直往左走或者一直往右走
不会回头， 因为回头多占用步数， 假设往右走能到达(i,j)这个位置，那么一定存在
一个a(a < j && j - a <= k  ===>  很明显的单调队列优化dp的条件)dp[i-1][a]=1成立


记录从下往上走不经过穿越（逆向思维）能到达每一列j的行数i，用vector R[j]存下i
思路同上

最后寻找最小的时候，从上面开始走的第j列选出行数i1（L[j]里面），从下面开始走的
第j列选出行数i2(R[j]里面)， 使得i2 > i1且i2 -i1最小，表示(i1,j)到(i2,j)这个位置
需要穿越，因为从上面不穿越一定可以到达(i1, j)， 从(i2,j)不穿越一定可以到达最下面
所以取(i2-i1)最小值就行了，如果最终结果为1表示不需要穿越
*/
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<set>
#include<cmath>
#include<stack>
#include<algorithm>
typedef long long ll;
const int INF = 1e9;
const int maxn = 1e3 + 100;
const ll mod = 1e9 + 7;
using namespace std;

int n, m, k;
int dp[maxn][maxn];
char s[maxn][maxn];
int que[maxn];
vector<int> L[maxn], R[maxn];

int main() {
    while(scanf("%d %d %d", &n, &m, &k) != EOF) {
        for(int i = 0; i < maxn; i++) {
            L[i].clear();
            R[i].clear();
        }
        memset(dp, 0, sizeof dp);
        for(int i = 1; i <= n; i++)
            scanf("%s", s[i] + 1);
        int num = 0;
        for(int i = 1; i <= m; i++) {
            dp[0][i] = 1;
            L[i].push_back(0);
        }
        for(int i = 1; i <= n + 1; i++) {
            ///从左边来的
            int t = 0, r = 0;
            for(int j = 1; j <= m; j++) {
                if(s[i][j] == 'x') { t = r; dp[i][j] = 0; continue; }
                if(dp[i - 1][j]) {
                    dp[i][j] = 1;
                    que[r++] = j;
                } else {
                    while(r > t && j - que[t] > k) t++;
                    if(r > t) dp[i][j] = 1;
                }
            }
            ///从右边来
            t = 0; r = 0;
            for(int j = m; j >= 1; j--) {
                if(s[i][j] == 'x') { t = r; dp[i][j] = 0; continue; }
                if(dp[i - 1][j]) {
                    dp[i][j] = 1;
                    que[r++] = j;
                } else {
                    while(r > t && que[t] - j > k) t++;
                    if(r > t) dp[i][j] = 1;
                }
            }
            for(int j = 1; j <= m; j++) {
                if(dp[i][j]) L[j].push_back(i);
            }
        }
        memset(dp, 0, sizeof dp);
        for(int i = 1; i <= m; i++) { dp[n + 1][i] = 1; R[i].push_back(n + 1); }
        for(int i = n; i >= 0; i--) {
            ///从左边来的
            int t = 0, r = 0;
            for(int j = 1; j <= m; j++) {
                if(s[i][j] == 'x') { t = r; dp[i][j] = 0; continue; }
                if(dp[i + 1][j]) {
                    dp[i][j] = 1;
                    que[r++] = j;
                } else {
                    while(r > t && j - que[t] > k) t++;
                    if(r > t) dp[i][j] = 1;
                }
            }
            ///从右边来
            t = 0; r = 0;
            for(int j = m; j >= 1; j--) {
                if(s[i][j] == 'x') { t = r; dp[i][j] = 0; continue; }
                if(dp[i + 1][j]) {
                    dp[i][j] = 1;
                    que[r++] = j;
                } else {
                    while(r > t && que[t] - j > k) t++;
                    if(r > t) dp[i][j] = 1;
                }
            }
            for(int j = 1; j <= m; j++) {
                if(dp[i][j]) R[j].push_back(i);
            }
        }
        for(int i = 0; i <= m; i++) {
            sort(R[i].begin(), R[i].end());
            sort(L[i].begin(), L[i].end());
        }
        int ans = INF;
        for(int i = 1; i <= m; i++) {
            int id = 0;
            for(int j = 0; j < L[i].size(); j++) {
                int nn = L[i][j];
                for( ; id < R[i].size(); id++) {
                    int mm = R[i][id];
                    if(mm > nn) { ans = min(ans, mm - nn); break; }
                }
            }
        }
        if(ans == 1) ans = 0;
        printf("%d\n", ans);
    }
    return 0;
}