1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

 /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        int ans = 0;  // 用于记录找到的'W'的数量

        // 遍历网格中的每个元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前元素是'W'，则增加计数器并执行深度优先搜索
                if (gridStr[i][j] == 'W') {
                    ans++;  // 增加计数器
                    dfs(gridStr, i, j);  // 执行深度优先搜索，标记相邻的'W'
                }

            }
        }

        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索(DFS)方法，用于遍历网格中的连通区域
     *
     * @param grid 二维字符网格
     * @param i    当前处理的行坐标
     * @param j    当前处理的列坐标
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前格子是'.'，表示已经是访问过的格子，直接返回
        if (grid[i][j] == '.') {
            return;
        }

        // 将当前格子标记为已访问（用'.'表示）
        grid[i][j] = '.';

        // 遍历当前格子的8个相邻方向（包括对角线方向）
        for (int di = -1; di <= 1; di++) {
            for (int dj = -1; dj <= 1; dj++) {
                // 跳过当前格子本身
                if (di == 0 && dj == 0) {
                    continue;
                }
                // 递归处理相邻格子
                dfs(grid, i + di, j + dj);
            }
        }

    }