时间复杂度：O(m*n) 每个格子最多遍历3遍。
空间复杂度：O(1)

class Solution {
public:
  vector<vector<int>> findFarmland(vector<vector<int>>& land) {
    const int m = land.size();
    const int n = land[0].size();
    vector<vector<int>> ans;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (!land[i][j]) continue;
        int w = 0;
        int h = 0;
        while (j + w < n && land[i][j + w]) ++w;
        while (i + h < m && land[i + h][j]) ++h;
        ans.push_back({i, j, i + h - 1, j + w - 1});
        for (int p = 0; p < h; ++p)
          for (int q = 0; q < w; ++q)
            land[i + p][j + q] = 0; // mark as seen.
      }
    return ans;
  }
};

You are given a 0-indexed m x n integer matrix grid and an integer k. You are currently at position (0, 0) and you want to reach position (m - 1, n - 1) moving only down or right.

Return the number of paths where the sum of the elements on the path is divisible by k. Since the answer may be very large, return it modulo 109 + 7.

Example 1:

Input: grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3
Output: 2
Explanation: There are two paths where the sum of the elements on the path is divisible by k.
The first path highlighted in red has a sum of 5 + 2 + 4 + 5 + 2 = 18 which is divisible by 3.
The second path highlighted in blue has a sum of 5 + 3 + 0 + 5 + 2 = 15 which is divisible by 3.

Example 2:

Input: grid = [[0,0]], k = 5
Output: 1
Explanation: The path highlighted in red has a sum of 0 + 0 = 0 which is divisible by 5.

Example 3:

Input: grid = [[7,3,4,9],[2,3,6,2],[2,3,7,0]], k = 1
Output: 10
Explanation: Every integer is divisible by 1 so the sum of the elements on every possible path is divisible by k.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 5 * 104
• 1 <= m * n <= 5 * 104
• 0 <= grid[i][j] <= 100
• 1 <= k <= 50

Solution: DP

Let dp[i][j][r] := # of paths from (0,0) to (i,j) with path sum % k == r.

init: dp[0][0][grid[0][0] % k] = 1

dp[i][j][(r + grid[i][j]) % k] = dp[i-1][j][r] + dp[i][j-1][r]

ans = dp[m-1][n-1][0]

Time complexity: O(m*n*k)
Space complexity: O(m*n*k) -> O(n*k)

// Author: Huahua
class Solution {
public:
  int numberOfPaths(vector<vector<int>>& grid, int k) {
    const int kMod = 1e9 + 7;
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(k)));
    dp[0][0][grid[0][0] % k] = 1;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (i == 0 && j == 0) continue;
        for (int r = 0; r < k; ++r)
          dp[i][j][(r + grid[i][j]) % k] = 
            ((j ? dp[i][j - 1][r] : 0) + (i ? dp[i - 1][j][r] : 0)) % kMod;          
      }
    return dp[m - 1][n - 1][0];
  }
};

Related Problems:

• 花花酱 LeetCode 62. Unique Paths

A guard can see every cell in the four cardinal directions (north, east, south, or west) starting from their position unless obstructed by a wall or another guard. A cell is guarded if there is at least one guard that can see it.

Return the number of unoccupied cells that are not guarded.

Example 1:

Input: m = 4, n = 6, guards = [[0,0],[1,1],[2,3]], walls = [[0,1],[2,2],[1,4]]
Output: 7
Explanation: The guarded and unguarded cells are shown in red and green respectively in the above diagram.
There are a total of 7 unguarded cells, so we return 7.

Example 2:

Input: m = 3, n = 3, guards = [[1,1]], walls = [[0,1],[1,0],[2,1],[1,2]]
Output: 4
Explanation: The unguarded cells are shown in green in the above diagram.
There are a total of 4 unguarded cells, so we return 4.

Constraints:

• 1 <= m, n <= 105
• 2 <= m * n <= 105
• 1 <= guards.length, walls.length <= 5 * 104
• 2 <= guards.length + walls.length <= m * n
• guards[i].length == walls[j].length == 2
• 0 <= rowi, rowj < m
• 0 <= coli, colj < n
• All the positions in guards and walls are unique.

Solution: Simulation

Enumerate each cell, for each guard, shoot rays to 4 directions, mark cells on the way to 1 and stop when hit a guard or a wall.

Time complexity: O(mn)
Space complexity: O(mn)

// Author: Huahua
class Solution {
public:
  int countUnguarded(int m, int n, vector<vector<int>>& guards, vector<vector<int>>& walls) {
    vector<vector<int>> s(m, vector<int>(n));
    for (const auto& g : guards)
      s[g[0]][g[1]] = 2;
    
    for (const auto& w : walls)
      s[w[0]][w[1]] = 3;
    
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (s[i][j] != 2) continue;
        for (int y = i - 1; y >= 0; s[y--][j] = 1)
          if (s[y][j] >= 2) break;          
        for (int y = i + 1; y < m; s[y++][j] = 1)
          if (s[y][j] >= 2) break;        
        for (int x = j - 1; x >= 0; s[i][x--] = 1)
          if (s[i][x] >= 2) break;    
        for (int x = j + 1; x < n; s[i][x++] = 1)
          if (s[i][x] >= 2) break;          
      }    
    int ans = 0;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        ans += !s[i][j];
    return ans;
  }
};

• 0 represents a wall that you cannot pass through.
• 1 represents an empty cell that you can freely move to and from.
• All other positive integers represent the price of an item in that cell. You may also freely move to and from these item cells.

It takes 1 step to travel between adjacent grid cells.

You are also given integer arrays pricing and start where pricing = [low, high] and start = [row, col] indicates that you start at the position (row, col) and are interested only in items with a price in the range of [low, high] (inclusive). You are further given an integer k.

You are interested in the positions of the k highest-ranked items whose prices are within the given price range. The rank is determined by the first of these criteria that is different:

1. Distance, defined as the length of the shortest path from the start (shorter distance has a higher rank).
2. Price (lower price has a higher rank, but it must be in the price range).
3. The row number (smaller row number has a higher rank).
4. The column number (smaller column number has a higher rank).

Return the k highest-ranked items within the price range sorted by their rank (highest to lowest). If there are fewer than k reachable items within the price range, return all of them.

Example 1:

Input: grid = [[1,2,0,1],[1,3,0,1],[0,2,5,1]], pricing = [2,5], start = [0,0], k = 3
Output: [[0,1],[1,1],[2,1]]
Explanation: You start at (0,0).
With a price range of [2,5], we can take items from (0,1), (1,1), (2,1) and (2,2).
The ranks of these items are:
- (0,1) with distance 1
- (1,1) with distance 2
- (2,1) with distance 3
- (2,2) with distance 4
Thus, the 3 highest ranked items in the price range are (0,1), (1,1), and (2,1).

Example 2:

Input: grid = [[1,2,0,1],[1,3,3,1],[0,2,5,1]], pricing = [2,3], start = [2,3], k = 2
Output: [[2,1],[1,2]]
Explanation: You start at (2,3).
With a price range of [2,3], we can take items from (0,1), (1,1), (1,2) and (2,1).
The ranks of these items are:
- (2,1) with distance 2, price 2
- (1,2) with distance 2, price 3
- (1,1) with distance 3
- (0,1) with distance 4
Thus, the 2 highest ranked items in the price range are (2,1) and (1,2).

Example 3:

Input: grid = [[1,1,1],[0,0,1],[2,3,4]], pricing = [2,3], start = [0,0], k = 3
Output: [[2,1],[2,0]]
Explanation: You start at (0,0).
With a price range of [2,3], we can take items from (2,0) and (2,1). 
The ranks of these items are: 
- (2,1) with distance 5
- (2,0) with distance 6
Thus, the 2 highest ranked items in the price range are (2,1) and (2,0). 
Note that k = 3 but there are only 2 reachable items within the price range.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 105
• 1 <= m * n <= 105
• 0 <= grid[i][j] <= 105
• pricing.length == 2
• 2 <= low <= high <= 105
• start.length == 2
• 0 <= row <= m - 1
• 0 <= col <= n - 1
• grid[row][col] > 0
• 1 <= k <= m * n

Solution: BFS + Sorting

Use BFS to collect reachable cells and sort afterwards.

Time complexity: O(mn + KlogK) where K = # of reachable cells.

Space complexity: O(mn)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> highestRankedKItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
    const int m = grid.size();
    const int n = grid[0].size();    
    const vector<int> dirs{1, 0, -1, 0, 1};    
    vector<vector<int>> seen(m, vector<int>(n));
    seen[start[0]][start[1]] = 1;
    vector<vector<int>> cells;
    queue<array<int, 3>> q;
    q.push({start[0], start[1], 0});
    while (!q.empty()) {
      auto [y, x, d] = q.front(); q.pop();
      if (grid[y][x] >= pricing[0] && grid[y][x] <= pricing[1])
          cells.push_back({d, grid[y][x], y, x});
      for (int i = 0; i < 4; ++i) {
        const int tx = x + dirs[i];
        const int ty = y + dirs[i + 1];
        if (tx < 0 || tx >= n || ty < 0 || ty >= m 
            || !grid[ty][tx] || seen[ty][tx]++) continue;
        q.push({ty, tx, d + 1});
      }
    }
    sort(begin(cells), end(cells), less<vector<int>>());
    vector<vector<int>> ans;
    for (int i = 0; i < min(k, (int)(cells.size())); ++i)
      ans.push_back({cells[i][2], cells[i][3]});
    return ans;
  }
};

• 1 which means a street connecting the left cell and the right cell.
• 2 which means a street connecting the upper cell and the lower cell.
• 3 which means a street connecting the left cell and the lower cell.
• 4 which means a street connecting the right cell and the lower cell.
• 5 which means a street connecting the left cell and the upper cell.
• 6 which means a street connecting the right cell and the upper cell.

You will initially start at the street of the upper-left cell (0,0). A valid path in the grid is a path which starts from the upper left cell (0,0) and ends at the bottom-right cell (m - 1, n - 1). The path should only follow the streets.

Notice that you are not allowed to change any street.

Return true if there is a valid path in the grid or false otherwise.

Example 1:

Input: grid = [[2,4,3],[6,5,2]]
Output: true
Explanation: As shown you can start at cell (0, 0) and visit all the cells of the grid to reach (m - 1, n - 1).

Example 2:

Input: grid = [[1,2,1],[1,2,1]]
Output: false
Explanation: As shown you the street at cell (0, 0) is not connected with any street of any other cell and you will get stuck at cell (0, 0)

Example 3:

Input: grid = [[1,1,2]]
Output: false
Explanation: You will get stuck at cell (0, 1) and you cannot reach cell (0, 2).

Example 4:

Input: grid = [[1,1,1,1,1,1,3]]
Output: true

Example 5:

Input: grid = [[2],[2],[2],[2],[2],[2],[6]]
Output: true

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• 1 <= grid[i][j] <= 6

Solution: BFS

Need to check both sides (x, y) -> (tx, ty) and (tx, ty) -> (x, y) to make sure a path exist.

Time complexity: O(m*n)
Space complexity: O(m*n)

// Author: Huahua
class Solution {
public:
  bool hasValidPath(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<int> dirs{0, -1, 0, 1, 0}; // [up, left, down, right]    
    vector<set<int>> rules{
      {1, 3}, {0, 2}, {1, 2}, 
      {2, 3}, {0, 1}, {0, 3}};
    queue<int> q{{0}};
    vector<int> seen(m * n);
    seen[0] = 1;
    while (!q.empty()) {
      int cx = q.front() % n;
      int cy = q.front() / n;      
      q.pop();
      if (cx == n - 1 && cy == m - 1) return true;      
      for (int d : rules[grid[cy][cx] - 1]) {
        int x = cx + dirs[d];
        int y = cy + dirs[d + 1];
        int key = y * n + x;
        if (x < 0 || x >= n || y < 0 || y >= m || seen[key] 
           || !rules[grid[y][x] - 1].count((d + 2) % 4)) continue;
        seen[key] = 1;
        q.push(key);
      }
    }
    return false;
  }
};

You are given a 2D char matrix representing the game board. ‘M’ represents an unrevealed mine, ‘E’ represents an unrevealed empty square, ‘B’ represents a revealed blank square that has no adjacent (above, below, left, right, and all 4 diagonals) mines, digit (‘1’ to ‘8’) represents how many mines are adjacent to this revealed square, and finally ‘X’ represents a revealed mine.

Now given the next click position (row and column indices) 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 – change it to ‘X’.
2. If an empty square (‘E’) with no adjacent mines is revealed, then change it to 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:

Input: 

[['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']]

Explanation:

Example 2:

Input: 

[['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']]

Explanation:

Note:

1. The range of the input matrix’s height and width is [1,50].
2. The click position will only be an unrevealed square (‘M’ or ‘E’), which also means the input board contains at least one clickable square.
3. The input board won’t be a stage when game is over (some mines have been revealed).
4. For simplicity, not mentioned rules should be ignored in this problem. For example, you don’t need to reveal all the unrevealed mines when the game is over, consider any cases that you will win the game or flag any squares.

Solution: DFS

Time complexity: O(m*n)
Space complexity: O(m* n)

// Author: Huahua
class Solution {
public:
  vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
    const int m = board.size();
    const int n = board[0].size();
    function<void(int, int)> dfs = [&](int x, int y) {
      if (board[y][x] != 'E') return;
      int c = 0;
      for (int tx = x - 1; tx <= x + 1; ++tx)
        for (int ty = y - 1; ty <= y + 1; ++ty)
          if (tx >= 0 && tx < n && ty >= 0 && ty < m)
            c += board[ty][tx] == 'M';
      
      if (c > 0) {
        board[y][x] = '0' + c;
        return;      
      }
      
      board[y][x] = 'B';      
      
      for (int tx = x - 1; tx <= x + 1; ++tx)
        for (int ty = y - 1; ty <= y + 1; ++ty)
          if (tx >= 0 && tx < n && ty >= 0 && ty < m)
            dfs(tx, ty);
    };
    int x = click[1];
    int y = click[0];
    dfs(x, y);
    if (board[y][x] == 'M') board[y][x] = 'X';
    return board;
  }
};

Solution 2: BFS

# Author: Huahua
class Solution:
  def updateBoard(self, board: List[List[str]], click: List[int]) -> List[List[str]]:
    m, n = len(board), len(board[0])
    cx, cy = click[1], click[0] 
    q = [(cx, cy)]
    while q:
      q2 = []
      for x, y in q:        
        if board[y][x] != 'E': continue
        c = 0
        for tx in range(x - 1, x + 2):
          for ty in range(y - 1, y + 2):
            if 0 <= tx < n and 0 <= ty < m and board[ty][tx] == 'M':
              c += 1
        if c > 0:
          board[y][x] = chr(ord('0') + c)
          continue
        board[y][x] = 'B'
        for tx in range(x - 1, x + 2):
          for ty in range(y - 1, y + 2):
            if 0 <= tx < n and 0 <= ty < m and board[ty][tx] == 'E':
              q2.append((tx, ty))              
      q = q2
    if board[cy][cx] == 'M': board[y][x] = 'X'
    return board

Return the minimum number of steps to walk from the upper left corner (0, 0) to the lower right corner (m-1, n-1) given that you can eliminate at most k obstacles. If it is not possible to find such walk return -1.

Example 1:

Input: 
grid = 
[[0,0,0],
 [1,1,0],
 [0,0,0],
 [0,1,1],
 [0,0,0]], 
k = 1
Output: 6
Explanation: 
The shortest path without eliminating any obstacle is 10. 
The shortest path with one obstacle elimination at position (3,2) is 6. Such path is (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).

Example 2:

Input: 
grid = 
[[0,1,1],
 [1,1,1],
 [1,0,0]], 
k = 1
Output: -1
Explanation: 
We need to eliminate at least two obstacles to find such a walk.

Constraints:

• grid.length == m
• grid[0].length == n
• 1 <= m, n <= 40
• 1 <= k <= m*n
• grid[i][j] == 0 or 1
• grid[0][0] == grid[m-1][n-1] == 0

Solution: BFS

State: (x, y, k) where k is the number of obstacles along the path.

Time complexity: O(m*n*k)
Space complexity: O(m*n*k)

// Author: Huahua, 8 ms, 10.5 MB
class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int k) {
    const vector<int> dirs{0, 1, 0, -1, 0};
    const int n = grid.size();
    const int m = grid[0].size();
    vector<vector<int>> seen(n, vector<int>(m, INT_MAX));
    queue<tuple<int, int, int>> q; 
    int steps = 0;
    q.emplace(0, 0, 0);
    seen[0][0] = 0;
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        int cx, cy, co;
        tie(cx, cy, co) = q.front(); q.pop();         
        if (cx == m - 1 && cy == n - 1) return steps;
        for (int i = 0; i < 4; ++i) {
          int x = cx + dirs[i];
          int y = cy + dirs[i + 1];
          if (x < 0 || y < 0 || x >= m || y >= n) continue;
          int o = co + grid[y][x];
          if (o >= seen[y][x] || o > k) continue;            
          seen[y][x] = o;
          q.emplace(x, y, o);
        }
      }
      ++steps;
    }
    return -1;
  }
};

Solution 2: DP

Time complexity: O(mnk)
Space complexity: O(mnk)

// AC 236 ms
class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int k) {
    constexpr int kInf = 1e9;
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<vector<int>>> dp(m + 2, vector<vector<int>>(n + 2, vector<int>(k + 1, kInf)));
    dp[1][1][0] = 0;
    for (int s = 0; s < 3; ++s)
      for (int i = 1; i <= m; ++i)
        for (int j = 1; j <= n; ++j) {
          const int o = grid[i - 1][j - 1];
          for (int z = 0; z + o <= k; ++z)
            dp[i][j][z + o] = min(dp[i][j][z + o],
                                  min({dp[i - 1][j][z],
                                       dp[i][j - 1][z],
                                       dp[i + 1][j][z],
                                       dp[i][j + 1][z]}) + 1);
        }
    int ans = *min_element(begin(dp[m][n]), end(dp[m][n]));
    return ans >= kInf ? -1 : ans;
  }
};

class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int K) {
    constexpr int kInf = 1e9;
    const vector<int> dirs{0, 1, 0, -1, 0};
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<vector<int>>> mem(m + 2, vector<vector<int>>(n + 2, vector<int>(K + 1, -1)));
    vector<vector<int>> seen(m + 2, vector<int>(n + 2));    
    function<int(int, int, int)> dp = [&](int x, int y, int k) {      
      if (x < 1 || x > n || y < 1 || y > m || k < 0 || seen[y][x]) return kInf;
      if (x == 1 && y == 1) return 0;
      if (mem[y][x][k] != -1) return mem[y][x][k];
      seen[y][x] = 1;
      int ans = kInf;
      for (int i = 0; i < 4; ++i)
        ans = min(ans, 1 + dp(x + dirs[i], y + dirs[i + 1], k - grid[y - 1][x - 1]));
      seen[y][x] = 0;      
      return mem[y][x][k] = ans;
    };        
    const int ans = dp(n, m, K);
    return ans >= kInf ? -1 : ans;
  }
};

Example 1:

Input: matrix =
[
  [0,1,1,1],
  [1,1,1,1],
  [0,1,1,1]
]
Output: 15
Explanation: 
There are 10 squares of side 1.
There are 4 squares of side 2.
There is  1 square of side 3.
Total number of squares = 10 + 4 + 1 = 15.

Example 2:

Input: matrix = 
[
  [1,0,1],
  [1,1,0],
  [1,1,0]
]
Output: 7
Explanation: 
There are 6 squares of side 1.  
There is 1 square of side 2. 
Total number of squares = 6 + 1 = 7.

Constraints:

• 1 <= arr.length <= 300
• 1 <= arr[0].length <= 300
• 0 <= arr[i][j] <= 1

Solution: DP

dp[i][j] := edge of largest square with bottom right corner at (i, j)
dp[i][j] = min(dp[i – 1][j], dp[i – 1][j – 1], dp[i][j – 1]) if m[i][j] == 1 else 0
ans = sum(dp)

Time complexity: O(n*m)
Space complexity: O(n*m)

// Author: Huahua
class Solution {
public:
  int countSquares(vector<vector<int>>& matrix) {
    const int n = matrix.size();
    const int m = matrix[0].size();
    // dp[i][j] := edge of largest square with right bottom corner at (i, j)
    vector<vector<int>> dp(n, vector<int>(m));
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < m; ++j) {
        dp[i][j] = matrix[i][j];
        if (i && j && dp[i][j])
          dp[i][j] = min({dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]}) + 1;
        ans += dp[i][j];
      }
    return ans;
  }
};

Example 1:

Input: grid = [[1,0],[0,1]]
Output: 0
Explanation: No servers can communicate with others.

Example 2:

Input: grid = [[1,0],[1,1]]
Output: 3
Explanation: All three servers can communicate with at least one other server.

Example 3:

Input: grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
Output: 4
Explanation: The two servers in the first row can communicate with each other. The two servers in the third column can communicate with each other. The server at right bottom corner can't communicate with any other server.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m <= 250
• 1 <= n <= 250
• grid[i][j] == 0 or 1

Solution: Counting

Two passes:
First pass, count number of computers for each row and each column.
Second pass, count grid[i][j] if rows[i] or cols[j] has more than 1 computer.

Time complexity: O(m*n)
Space complexity: O(m + n)

// Author: Huahua
class Solution {
public:
  int countServers(vector<vector<int>>& grid) {
    const size_t m = grid.size();
    const size_t n = grid[0].size();
    vector<int> rows(m);
    vector<int> cols(n);
    for (size_t i = 0; i < m; ++i)
      for (size_t j = 0; j < n; ++j) {
        rows[i] += grid[i][j];
        cols[j] += grid[i][j];
      }
    int ans = 0;
     for (size_t i = 0; i < m; ++i)
      for (size_t j = 0; j < n; ++j)
        ans += (rows[i] > 1 || cols[j] > 1) ? grid[i][j] : 0;
    return ans;
  }
};

Return the maximum amount of gold you can collect under the conditions:

• Every time you are located in a cell you will collect all the gold in that cell.
• From your position you can walk one step to the left, right, up or down.
• You can’t visit the same cell more than once.
• Never visit a cell with 0 gold.
• You can start and stop collecting gold from any position in the grid that has some gold.

Example 1:

Input: grid = [[0,6,0],[5,8,7],[0,9,0]]
Output: 24
Explanation:
[[0,6,0],
 [5,8,7],
 [0,9,0]]
Path to get the maximum gold, 9 -> 8 -> 7.

Example 2:

Input: grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]
Output: 28
Explanation:
[[1,0,7],
 [2,0,6],
 [3,4,5],
 [0,3,0],
 [9,0,20]]
Path to get the maximum gold, 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7.

Constraints:

• 1 <= grid.length, grid[i].length <= 15
• 0 <= grid[i][j] <= 100
• There are at most 25 cells containing gold.

Solution: DFS

Time compleixty: O(4^25) ???
Space complexity: O(25)

// Author: Huahua
class Solution {
public:
  int getMaximumGold(vector<vector<int>>& g) {
    int n = g.size();
    int m = g[0].size();
    int ans = 0;
    function<int(int, int)> dfs = [&](int x, int y) {
      if (x < 0 || x >= m || y < 0 || y >= n || g[y][x] == 0) return 0;
      int c = 0;
      swap(c, g[y][x]);
      int r = c + max({dfs(x - 1, y), dfs(x + 1, y), dfs(x, y - 1), dfs(x, y + 1)});
      swap(c, g[y][x]);
      return r;
    };
    for (int i = 0; i < n; ++i) 
      for (int j = 0; j < m; ++j)        
        ans = max(ans, dfs(j, i));
    return ans;
  }
};

Example 1:

Input: grid = [[1,1,1],[1,0,1],[1,1,1]]
Output: 9

Example 2:

Input: grid = [[1,1,0,0]]
Output: 1

Constraints:

• 1 <= grid.length <= 100
• 1 <= grid[0].length <= 100
• grid[i][j] is 0 or 1

Solution: DP

Compute the sums of all rectangles that has left-top corner at (0, 0) in O(m*n) time.
For each square and check whether its borders are all ones in O(1) time.

Time complexity: O(m*n*min(m,n))
Space complexity: O(m*n)

// Author: Huahua
class Solution {
public:
  int largest1BorderedSquare(vector<vector<int>>& grid) {
    int n = grid.size();
    int m = grid[0].size();
    vector<vector<int>> dp(n + 1, vector<int>(m + 1));
    for (int i = 1; i <= n; ++i)
      for (int j = 1; j <= m; ++j)
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + grid[i - 1][j - 1];
    
    for (int len = min(n, m); len > 0; --len)
      for (int x1 = 1, x2 = x1 + len - 1; x2 <= m; ++x1, ++x2)
        for (int y1 = 1, y2 = y1 + len - 1; y2 <= n; ++y1, ++y2)
          if (getArea(x1, y1, x2, y1, dp) == len 
              && getArea(x1, y1, x1, y2, dp) == len
              && getArea(x1, y2, x2, y2, dp) == len
              && getArea(x2, y1, x2, y2, dp) == len)            
            return len * len;        
    return 0;
  }
private:
  int getArea(int x1, int y1, int x2, int y2, const vector<vector<int>>& dp) {
    return dp[y2][x2] - dp[y2][x1 - 1] - dp[y1 - 1][x2] + dp[y1 - 1][x1 - 1];
  }
};

• the value 0 representing an empty cell;
• the value 1 representing a fresh orange;
• the value 2 representing a rotten orange.

Every minute, any fresh orange that is adjacent (4-directionally) to a rotten orange becomes rotten.

Return the minimum number of minutes that must elapse until no cell has a fresh orange.  If this is impossible, return -1instead.

Example 1:

Input: [[2,1,1],[1,1,0],[0,1,1]]
Output: 4

Example 2:

Input: [[2,1,1],[0,1,1],[1,0,1]]
Output: -1
Explanation:  The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.

Example 3:

Input: [[0,2]]
Output: 0
Explanation:  Since there are already no fresh oranges at minute 0, the answer is just 0.

Note:

1. 1 <= grid.length <= 10
2. 1 <= grid[0].length <= 10
3. grid[i][j] is only 0, 1, or 2.

Solution: BFS

Time complexity: O(mn)
Space complexity: O(mn)

// Author: Huahua, Running time: 12 ms, 10.8 MB
class Solution {
public:
  int orangesRotting(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    queue<pair<int,int>> q;
    int fresh = 0;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (grid[i][j] == 1) ++fresh;
        else if (grid[i][j] == 2) q.emplace(j, i);
    vector<int> dirs = {1, 0, -1, 0, 1};    
    int days = 0;
    while (!q.empty() && fresh) {
      int size = q.size();
      while (size--) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        for (int i = 0; i < 4; ++i) {
          int dx = x + dirs[i];
          int dy = y + dirs[i + 1];
          if (dx < 0 || dx >= n || dy < 0 || dy >= m || grid[dy][dx] != 1) continue;
          --fresh;
          grid[dy][dx] = 2;
          q.emplace(dx, dy);
        }
      }
      ++days;
    }    
    return fresh ? -1 : days;
  }
};

Example:

Input:
[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
Output: 6

Solution: DP

Time complexity: O(m^2*n)
Space complexity: O(mn)

dp[i][j] := max length of all 1 sequence ends with col j, at the i-th row.
transition:
dp[i][j] = 0 if matrix[i][j] == ‘0’
= dp[i][j-1] + 1 if matrix[i][j] == ‘1’

class Solution {
public:
  int maximalRectangle(vector<vector<char> > &matrix) {
    int r = matrix.size();
    if (r == 0) return 0;
    int c = matrix[0].size();
  
    // dp[i][j] := max len of all 1s ends with col j at row i.
    vector<vector<int>> dp(r, vector<int>(c));

    for (int i = 0; i < r; ++i)
      for (int j = 0; j < c; ++j)
        dp[i][j] = (matrix[i][j] == '1') ? (j == 0 ? 1 : dp[i][j - 1] + 1) : 0;

    int ans = 0;

    for (int i = 0; i < r; ++i)
      for (int j = 0; j < c; ++j) {
        int len = INT_MAX;
        for (int k = i; k < r; k++) {
          len = min(len, dp[k][j]);
          if (len == 0) break;
          ans = max(len * (k - i + 1), ans);
        }
    }

    return ans;
  }
};

Problem

You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells). The island doesn’t have “lakes” (water inside that isn’t connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don’t exceed 100. Determine the perimeter of the island.

Example:

[[0,1,0,0],
 [1,1,1,0],
 [0,1,0,0],
 [1,1,0,0]]

Answer: 16
Explanation: The perimeter is the 16 yellow stripes in the image below:

Solution: Counting

If a land has 0 neighbour, it contributes 4 to the perimeter

If a land has 1 neighbour, it contributes 3 to the perimeter

If a land has 2 neighbours, it contributes 2 to the perimeter

If a land has 3 neighbours, it contributes 1 to the perimeter

If a land has 4 neighbours, it contributes 0 to the perimeter

perimeter = area * 4 – total_neighbours

Time complexity: O(mn)

Space complexity: O(1)

// Author: Huahua
// Running time: 148 ms
class Solution {
public:
  int islandPerimeter(vector<vector<int>>& grid) {
    if (grid.empty()) return 0;
    int m = grid.size();
    int n = grid[0].size();
    int area = 0;
    int conn = 0;

    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        if (grid[y][x] == 1) {
          ++area;
          if (y > 0 && grid[y - 1][x] == 1) ++conn;
          if (x > 0 && grid[y][x - 1] == 1) ++conn;
        }

    return area*4 - conn*2;
  }
};

Problem

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int calculateMinimumHP(vector<vector<int>>& dungeon) {      
    const int m = dungeon.size();
    const int n = dungeon[0].size();

    // hp[y][x]: min hp required to reach bottom right (P).
    vector<vector<int>> hp(m + 1, vector<int>(n + 1, INT_MAX));
    hp[m][n - 1] = hp[m - 1][n] = 1;

    for (int y = m - 1; y >= 0; --y)
      for (int x = n - 1; x >= 0; --x)
        hp[y][x] = max(1, min(hp[y + 1][x], hp[y][x + 1]) - dungeon[y][x]);

    return hp[0][0];
  }
};

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int calculateMinimumHP(vector<vector<int>>& dungeon) {      
    const int m = dungeon.size();
    const int n = dungeon[0].size();

    // hp[y][x]: min hp required to reach bottom right (P).
    vector<int> hp(n + 1, INT_MAX);
    hp[n - 1] = 1;

    for (int y = m - 1; y >= 0; --y)
      for (int x = n - 1; x >= 0; --x)
        hp[x] = max(1, min(hp[x], hp[x + 1]) - dungeon[y][x]);

    return hp[0];
  }
};