Posts tagged as “grid”

花花酱 LeetCode 1293. Shortest Path in a Grid with Obstacles Elimination

By zxi on December 14, 2019

iven a m * n grid, where each cell is either 0 (empty) or 1 (obstacle). In one step, you can move up, down, left or right from and to an empty cell.

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)

C++

// 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)

Bottom-Up

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

}

};

Top-Down

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;

}

};

花花酱 LeetCode 1277. Count Square Submatrices with All Ones

By zxi on December 1, 2019

Given a m * n matrix of ones and zeros, return how many square submatrices have all ones.

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)

C++

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

}

};

花花酱 LeetCode 1267. Count Servers that Communicate

By zxi on November 23, 2019

You are given a map of a server center, represented as a m * n integer matrix grid, where 1 means that on that cell there is a server and 0 means that it is no server. Two servers are said to communicate if they are on the same row or on the same column.

Return the number of servers that communicate with any other server.

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)

C++

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

}

};

花花酱 LeetCode 1219. Path with Maximum Gold

By zxi on October 5, 2019

In a gold mine grid of size m * n, each cell in this mine has an integer representing the amount of gold in that cell, 0 if it is empty.

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)

C++

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

}

};

花花酱 LeetCode 1139. Largest 1-Bordered Square

By zxi on July 27, 2019

Given a 2D grid of 0s and 1s, return the number of elements in the largest square subgrid that has all 1s on its border, or 0 if such a subgrid doesn’t exist in the grid.

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)

C++

// 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];

}

};