9、Acwing 2021/1/21 1113. 红与黑

9、Acwing 2021/1/21 1113. 红与黑

1113. 红与黑

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。

你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。

请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

输入格式

输入包括多个数据集合。

每个数据集合的第一行是两个整数 WW 和 HH，分别表示 xx 方向和 yy 方向瓷砖的数量。

在接下来的 HH 行中，每行包括 WW 个字符。每个字符表示一块瓷砖的颜色，规则如下

1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。

当在一行中读入的是两个零时，表示输入结束。

输出格式

对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

数据范围

1≤W,H≤201≤W,H≤20

输入样例：

6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0

输出样例：

45

方法一：DFS

import java.util.*;
public class Main{
    static int[]dx = {-1,0,1,0};
    static int[]dy = {0,1,0,-1};
    static int n , m;
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
    
        while(true){
            
            m = sc.nextInt();
            n = sc.nextInt();
            if(n == 0 && m == 0 ){
                break;
            }
            
            boolean[][] st = new boolean[n][m];
            char[][] arr = new char[n][m];
            
            int x = 0 , y = 0;
            
            for(int i = 0 ; i < n ; i ++){
                String rs = sc.next(); //接收一行字符
                for(int j = 0 ; j < m ; j++){
                    arr[i][j] = rs.charAt(j); //把一行字符串，分割成一个个字符
                    //计录下标
                    if(arr[i][j] == '@'){
                        x = i;
                        y = j;
                    }
                }
            }
            System.out.println(dfs(arr,st,x,y));
        }
    }
    
    static int dfs(char[][] arr , boolean[][] st , int x , int y){
        //计数
        int res = 1;
        st[x][y] = true; //标记
        
        //四个方向
        for(int i = 0 ; i < 4 ; i++){
            int a = x + dx[i];
            int b = y + dy[i];
            
            //判断边界，和是否标记、墙
            if(a < 0 || a >= n || b < 0 || b >= m || st[a][b] == true|| arr[a][b] == '#'){
                continue;
            }
            res += dfs(arr,st,a,b);
        }
        return res;
    }
}

方法二：BFS

import java.io.*;
import java.util.*;
class Main{
   
    static int N = 25;
    static char[][] a = new char[N][N];
    static int[][] dir = new int[][]{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            String[] ss = sc.nextLine().split(" ");
            int row = Integer.valueOf(ss[1]);
            int col = Integer.valueOf(ss[0]);
            if(row == 0 && col == 0) break;
            boolean[][] st = new boolean[row][col];
            Queue<int[]> q = new LinkedList();
            int x1 = 0, y1 = 0;
            for(int i = 0; i < row; i++){
                String s = sc.nextLine();
                for(int j = 0; j < col; j++){
                    a[i][j] = s.charAt(j);
                    if(a[i][j] == '@'){
                        x1 = i; y1 = j;
                    }
                }
            }
            int cnt = 0;
            st[x1][y1] = true;
            q.offer(new int[]{x1, y1});
            while(!q.isEmpty()){
                int[] poll = q.poll();
                cnt++;
                for(int i = 0; i < 4; i++){
                    int nx = dir[i][0] + poll[0];
                    int ny = dir[i][1] + poll[1];
                    if(nx < 0 || nx >= row || ny < 0 || ny >= col) continue;
                    if(st[nx][ny] || a[nx][ny] == '#') continue;
                    st[nx][ny] = true;
                    q.offer(new int[]{nx, ny});
                }
            }
            System.out.println(cnt);

        }
    }
}