【Codeforces 1063B】Labyrinth

【链接】 我是链接,点我呀:)
【题意】

你可以往左最多x次,往右最多y次
问你从x,y出发最多能到达多少个格子
只能往上下左右四个方向走到没有障碍的格子

【题解】

假设我们从(r,c)出发想要到固定某个点(i,j)的最短距离
我们设x0为向左走动的次数,y0为向右走动的次数
显然(j-c)=y0-x0
即y0 = (j-c) + x0
这里j-c是一个常数
也就是说当我们让x0最小的时候到达每一个点的对应的y0也一定是最优的,因为和x0成正相关
因此我们只要求出来(r,c)到所有点所用的x0的最小值就好了
会发现没个点到达相邻的点的花费要么就是1(往左走),要么就是0(往其他方向走)
符合01bfs的特点
(01bfs:如果向左走的话,那么就把新得到的状态加入到末尾,否则加入到队头,因为花费为0的话,和之前的dis值相同,依然是当前所有的情况里最低花费
(所以可以用来继续更新最小值,因此是放在队头,这样的话能始终维持队列从头到尾的dis值依次递增的顺序
(因此能保证每次尝试用来更新的状态都是当前状况下最优的状态,不会造成错解或者漏解

【代码】

import java.io.*;
import java.util.*;

public class Main {
    
    
    static InputReader in;
    static PrintWriter out;
        
    public static void main(String[] args) throws IOException{
        //InputStream ins = new FileInputStream("E:\\rush.txt");
        InputStream ins = System.in;
        in = new InputReader(ins);
        out = new PrintWriter(System.out);
        //code start from here
        new Task().solve(in, out);
        out.close();
    }
    
    static class Pair{
        int x,y,d;
        public Pair(int x,int y,int d){
            this.x = x;
            this.y = y;
            this.d = d;
        }
    }
    
    static int N = 2000;
    static class Task{
        int n,m,r,c,x,y;
        String s[];
        int dis[][];
        int dx[]= {0,0,1,-1},dy[]= {1,-1,0,0};
        Deque<Pair> queue;
        
        public void solve(InputReader in,PrintWriter out) {
            queue = new LinkedList<Pair>();
            dis = new int[N+10][N+10];
            s = new String[N+10];
            n = in.nextInt();m = in.nextInt();
            r = in.nextInt();c = in.nextInt();
            x = in.nextInt();y = in.nextInt();
            for (int i = 1;i <= n;i++)  {
                s[i] = in.next();
                StringBuilder sb = new StringBuilder(s[i]);
                sb.insert(0, ' ');
                s[i] = sb.toString();
            }
            for (int i = 1;i <= N;i++)
                for (int j = 1;j <= N;j++)
                    dis[i][j] = -1;
            
            dis[r][c] = 0;
            queue.offerFirst(new Pair(r,c,0));
            while (!queue.isEmpty()) {
                Pair temp = queue.pollFirst();
                int x0 = temp.x,y0 = temp.y,d = temp.d;
                for (int i = 0;i < 4;i++) {
                    int x1 = x0 + dx[i];int y1 = y0 + dy[i];
                    int td = d;
                    if (i==1) td++;
                    if (x1>=1 && x1<=n && y1>=1 && y1<=m && s[x1].charAt(y1)!='*') {
                        if (dis[x1][y1]==-1 ||dis[x1][y1]>td) {
                            dis[x1][y1] = td;
                            if (i==1) {
                                queue.offerLast(new Pair(x1,y1,td));
                            }else {
                                queue.offerFirst(new Pair(x1,y1,td));
                            }
                        }
                    }
                }
            }
            int ans = 0;
            for (int i = 1;i <= n;i++)
                for (int j = 1;j <= m;j++) {
                    if (dis[i][j]==-1) continue;
                    int x0 = dis[i][j];
                    int y0 = j-c + x0;
                    if (x0<=x && y0<=y) {
                        ans++;
                    }
                }
            out.println(ans);
        }
    }

    

    static class InputReader{
        public BufferedReader br;
        public StringTokenizer tokenizer;
        
        public InputReader(InputStream ins) {
            br = new BufferedReader(new InputStreamReader(ins));
            tokenizer = null;
        }
        
        public String next(){
            while (tokenizer==null || !tokenizer.hasMoreTokens()) {
                try {
                tokenizer = new StringTokenizer(br.readLine());
                }catch(IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}