CodeForces - 1063B Labyrinth （ 0-1 BFS）

题意：

给定一个矩阵，你在一个给定坐标，规定向左右走的步数有限，计算你能走的最大步数。

分析：

之前碰过这种题，不能直接用普通的bfs，先不说时间复杂度，就且说算法的正确性都不对

原因在于如果一条路先到(x,y)，但是却不能走到(x1,y1)，却阻断了其他路通向这里，因为你会发现向左走和向右走是相互独立的。

也就是说一个只能向左走L步的点和一个只能向右走R步的点同时在(x,y)这个点上，可以看成一个在(x,y)可以向左走L步和向右走R步

的点。所以记两个变量就可以了。

设从一个点走到点，向右走R步向左走L步。那么可以得出   (规定向右为正方向)。

设为，那么,从而只需要计算一个变量即可。

而每次都是走一步，只用计算向左（右）走的，那么向左（右）走一步为1，那么向右（左）走一步为0。（因为只用计算一个方向

即可）那么这样便可以借助最短路算法的更新操作进行维护。

同时因为是0-1路，所以采用deque进行维护，路径为0的放在队首优先维护最短路。

附上一篇0-1最短路算法。

#include<bits/stdc++.h>

using namespace std;

struct node{
    int x,y;
    node(int x=0,int y=0):x(x),y(y){}
};

int n,m,r,c,x,y;

const int maxn=2000+10;

const int inf=0x3f3f3f3f;

char g[maxn][maxn];
int dis[maxn][maxn];

int dx[]={0,0,-1,1};
int dy[]={-1,1,0,0};

void bfs(){
    deque<node> q;
    q.push_front(node(r-1,c-1));
    memset(dis,inf,sizeof dis);
    dis[r-1][c-1]=0;
    while(!q.empty()){
        node tmp=q.front();
        q.pop_front();
        for(int i=0;i<4;i++){
            int tx=tmp.x+dx[i];
            int ty=tmp.y+dy[i];
            if(tx<0||tx>=n||ty<0||ty>=m||g[tx][ty]=='*') continue;
            if(dis[tx][ty]>dis[tmp.x][tmp.y]+(i==0)){
                dis[tx][ty]=dis[tmp.x][tmp.y]+(i==0);
                if(i==0) q.push_back(node(tx,ty));
                else q.push_front(node(tx,ty));
            }
        }
    }
}

int main(){

    scanf("%d%d%d%d%d%d",&n,&m,&r,&c,&x,&y);
    for(int i=0;i<n;i++){
        scanf("%s",g[i]);
    }
    bfs();
    int ans=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(g[i][j]=='*') continue;
            int yy=dis[i][j]+j-(c-1);
            if(dis[i][j]<=x&&yy<=y){
                ans++;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}