CF D. Labyrinth 01BFS

由于上下走不限制，所以按照贪心，我们应该尽可能走上下方向.
我们可以开一个双端队列，并认为每次提取队首的时候得到的是到达该点的最优策略.(这个一定是唯一的，因为不可能向右走几格，然后再退回去. )
那么如果向上下走是不损失的，所以将上下的格子推进队首，优先扩展，然后将左右推进队尾，最后扩展.
这个贪心是正确的，可以保证每一个格子被扩展时都是最优策略.

#include<bits/stdc++.h>
#define maxn 2003 
using namespace std;  
void setIO(string s) {
    string in=s+".in"; 
    freopen(in.c_str(),"r",stdin);          
}  
int dx[]={0,1,0,-1}; 
int dy[]={1,0,-1,0};   
struct Node { 
    int x,y; 
    Node(int y=0,int x=0):x(x),y(y){} 
};          
deque<Node>Q;      
int n,m,r,c,X,Y;
int G[maxn][maxn],vis[maxn][maxn],L[maxn][maxn],R[maxn][maxn];        
char str[maxn];  
int main() {
    int cc=1; 
    // setIO("input"); 
    scanf("%d%d%d%d%d%d",&n,&m,&r,&c,&X,&Y);     
    for(int i=1;i<=n;++i) {
        scanf("%s",str+1); 
        for(int j=1;j<=m;++j) G[i][j]=!(str[j]=='.'); 
    }         
    vis[r][c]=1;        
    Q.push_back(Node(r, c));   
    while(!Q.empty()) {
        Node u=Q.front(); Q.pop_front(); 
        for(int i=0;i<4;++i) {    
            int x=u.x+dx[i],y=u.y+dy[i];  
            if(x<1||x>m||y<1||y>n||vis[y][x]||G[y][x]) continue;                         
            vis[y][x]=1;        
            L[y][x]=L[u.y][u.x]; 
            R[y][x]=R[u.y][u.x];                      
            if(x<u.x) {
                if(L[u.y][u.x] + 1 > X) continue;         
                else {   
                    L[y][x]=L[u.y][u.x]+1;  
                    Q.push_back(Node(y, x));      
                    ++cc;  
                    continue; 
                }
            }  
            if(x>u.x) {            
                if(R[u.y][u.x] + 1 > Y) continue;   
                else {
                    R[y][x]=R[u.y][u.x]+1;    
                    Q.push_back(Node(y,x));    
                    ++cc; 
                    continue;   
                }
            } 
            Q.push_front(Node(y,x));      
            ++cc;   
        }
    } 
    printf("%d\n",cc);  
    return 0;      
}