g0501_0600.s0529_minesweeper.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0501_0600.s0529_minesweeper;

// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
// #2022_07_28_Time_0_ms_(100.00%)_Space_42.6_MB_(85.88%)

/**
 * 529 - Minesweeper\.
 *
 * Medium
 *
 * Let's play the minesweeper game ([Wikipedia](https://en.wikipedia.org/wiki/Minesweeper_(video_game)), [online game](http://minesweeperonline.com))!
 *
 * You are given an `m x n` char matrix `board` representing the game board where:
 *
 * *   `'M'` represents an unrevealed mine,
 * *   `'E'` represents an unrevealed empty square,
 * *   `'B'` represents a revealed blank square that has no adjacent mines (i.e., above, below, left, right, and all 4 diagonals),
 * *   digit (`'1'` to `'8'`) represents how many mines are adjacent to this revealed square, and
 * *   `'X'` represents a revealed mine.
 *
 * You are also given an integer array `click` where click = [click_r, click_c] represents the next click position among all the unrevealed squares (`'M'` or `'E'`).
 *
 * Return _the board after revealing this position according to the following rules_:
 *
 * 1.  If a mine `'M'` is revealed, then the game is over. You should change it to `'X'`.
 * 2.  If an empty square `'E'` with no adjacent mines is revealed, then change it to a revealed blank `'B'` and all of its adjacent unrevealed squares should be revealed recursively.
 * 3.  If an empty square `'E'` with at least one adjacent mine is revealed, then change it to a digit (`'1'` to `'8'`) representing the number of adjacent mines.
 * 4.  Return the board when no more squares will be revealed.
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_1.png)
 *
 * **Input:** board = \[\["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0]
 *
 * **Output:** [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
 *
 * **Example 2:**
 *
 * ![](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_2.png)
 *
 * **Input:** board = \[\["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2]
 *
 * **Output:** [["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
 *
 * **Constraints:**
 *
 * *   `m == board.length`
 * *   `n == board[i].length`
 * *   `1 <= m, n <= 50`
 * *   `board[i][j]` is either `'M'`, `'E'`, `'B'`, or a digit from `'1'` to `'8'`.
 * *   `click.length == 2`
 * *   0 <= click_r < m
 * *   0 <= click_c < n
 * *   board[click_r][click_c] is either `'M'` or `'E'`.
**/
public class Solution {
    private static final int[][] DIRECTION = {
        {1, 0}, {-1, 0}, {0, 1}, {0, -1}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}
    };

    private int row;
    private int col;

    private void dfs(char[][] board, int row, int col) {
        if (row < 0 || row >= this.row || col < 0 || col >= this.col) {
            return;
        }
        if (board[row][col] == 'E') {
            int numOfMine = bfs(board, row, col);
            if (numOfMine != 0) {
                board[row][col] = (char) (numOfMine + '0');
                return;
            } else {
                board[row][col] = 'B';
            }
            for (int[] i : DIRECTION) {
                dfs(board, row + i[0], col + i[1]);
            }
        }
    }

    private int bfs(char[][] board, int row, int col) {
        int numOfMine = 0;

        for (int[] i : DIRECTION) {
            int newRow = row + i[0];
            int newCol = col + i[1];
            if (newRow >= 0
                    && newRow < this.row
                    && newCol >= 0
                    && newCol < this.col
                    && board[newRow][newCol] == 'M') {
                numOfMine++;
            }
        }

        return numOfMine;
    }

    public char[][] updateBoard(char[][] board, int[] c) {
        if (board[c[0]][c[1]] == 'M') {
            board[c[0]][c[1]] = 'X';
            return board;
        } else {
            row = board.length;
            col = board[0].length;
            dfs(board, c[0], c[1]);
        }
        return board;
    }
}