529. Minesweeper

Problem

Let's play the minesweeper game (Wikipedia, online game)!

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 = [clickr, clickc] 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:

• If a mine 'M' is revealed, then the game is over. You should change it to 'X'.

• 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.

• 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.

• Return the board when no more squares will be revealed.

  Example 1:

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:

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 <= clickr < m

• 0 <= clickc < n

• board[clickr][clickc] is either 'M' or 'E'.

Solution (Java)

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;
    }
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).