迷宫中的极客

Geek 在一个大小为N * M的迷宫中。迷宫中的每个单元都由“。”组成。或'#' 。空单元格由“.”表示障碍物由'#'表示。任务是找出他可以通过多少个不同的空单元格如果 Geek 从单元格(R, C)开始并避开障碍物，他可以向四个方向中的任何一个方向移动，但他最多可以向上移动U次并且他最多可以向下移动D次。

例子：

Input: N = 3, M = 3,
R = 1, C = 0
U = 1, D = 1
mat = {{. . .}, {. # .}, {# . .}}
Output: 5
Explanation: Geek can reach
(1, 0), (0, 0), (0, 1), (0, 2), (1, 2)

Input: N = 3, M = 4, R = 1, C = 0, U = 1, D = 2
mat = {{. . .}, {. # .}, {. . .}, {# . .}}
Output: 10
Explanation: Geek can reach all the
cells except for the obstacles.

编程需要懂一点英语

方法：解决这个问题的思路是基于以下思路：

Keep moving radially in all four directions (up, down, left, right) and keep counting the number of turning taken in moving up and down. If the number of turns left for given upward and downward movements are not 0 then move to up and down and keep counting the empty cells.

编程需要懂一点英语

按照下面提到的步骤来实现这个想法：

检查起点是否被障碍物阻挡（#）
- 如果为真，则返回0 。
保留一个数组队列来存储任何单元格的行、列、上升和下降。
进行 BFS 遍历：
- 检查单元格是否为空，然后增加计数变量（比如cnt ）。
- 检查是否有任何向上移动。
  - 如果保留向上移动，则向上移动并减少向上移动计数并推送队列中单元格的当前状态。
- 检查是否有任何向下移动。
  - 如果向下移动，则向下移动并减少向下移动计数，并推送队列中单元格的当前状态。
最后，返回cnt 。

下面是上述方法的实现：

C++

// C++ code to implement the approach
  
#include 
using namespace std;
  
// Function to count different empty cells 
// he can pass through while avoiding
// the obstacles
int numberOfCells(int n, int m, int r,
                  int c, int u, int d,
                  vector >& mat)
{
    // If cell having Obstacle
    if (mat[r] == '#')
        return 0;
  
    queue > que;
    int cnt = 0;
    int i = 0;
    int j = 0;
  
    mat[r] = '#';
    que.push({ r, c, u, d });
  
    // BFS traversal of the matrix
    while (que.size()) {
        auto& f = que.front();
        int rr = f[0];
        int cc = f[1];
        int uu = f[2];
        int dd = f[3];
        que.pop();
  
        ++cnt;
  
        // Move left
        i = rr;
        j = cc - 1;
        if (0 <= j && mat[i][j] == '.') {
  
            // Mark the cell visited
            mat[i][j] = '#';
            que.push({ i, j, uu, dd });
        }
  
        // Move right
        i = rr;
        j = cc + 1;
        if (j < m && mat[i][j] == '.') {
  
            // Mark the cell visited
            mat[i][j] = '#';
            que.push({ i, j, uu, dd });
        }
  
        // Move up
        i = rr - 1;
        j = cc;
        if (0 <= i && mat[i][j] == '.' && uu) {
  
            // Mark the cell visited
            mat[i][j] = '#';
            que.push({ i, j, uu - 1, dd });
        }
  
        // Move down
        i = rr + 1;
        j = cc;
        if (i < n && mat[i][j] == '.' && dd) {
  
            // Mark the cell visited
            mat[i][j] = '#';
            que.push({ i, j, uu, dd - 1 });
        }
    }
  
    // Return the count
    return cnt;
}
  
// Driver code
int main()
{
    int N = 3, M = 3, R = 1, C = 0;
    int U = 1, D = 1;
    vector > mat = { { '.', '.', '.' },
                                  { '.', '#', '.' },
                                  { '#', '.', '.' } };
  
    // Function call
    cout << numberOfCells(N, M, R, C, U, D, mat);
    return 0;
}

输出

时间复杂度： O(N * M)
辅助空间： O(N * M)