Matrix on Jiang Yi(姜祎)'s Homepage

2812. Find the Safest Path in a Grid

Wed, 15 May 2024 20:24:56 +0800

Given a matrix, we wish to find a path that from start to end, such that the path is as far as from the dangerous position.

Intuition

We can convert the problem into finding a path with minimum weights in a graph.

Approach

We first convert the matrix into a graph, with node as position (i, j) and weight w[i,j]\min_k(|i-thief[k][0]| + |j - thief[k][1]|), where thief[k]=(thief[k][0], thief[k][1]) is the position of the thief thief[k]. To do this, we can use DFS, starting from each thief and iterate through the grids.

Then, we need to find a path from the start (0, 0) to target (n - 1, n - 1). This can be done via Dijkstra’s Algorithm. We use a priority queue to keep track of minimum to-be-visited nodes, this ensures that the newly added nodes are always with the maximum safe factor.

Complexity

Time complexity: iterate all elements twice, the second trial requires to maintain the priority queue.
$$O(n^2\log n)$$
Space complexity: store safe factors matrix.
$$O(n^2)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

public:
 int maximumSafenessFactor(vector<vector<int>>& grid) {
 int n = grid.size();
 if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1)
 return 0;

 vector<vector<int>> scores(n, vector<int>(n, INT_MAX));
 queue<pair<int, int>> q;
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < n; ++j) {
 if (grid[i][j] == 0)
 continue;
 q.push(make_pair(i, j));
 scores[i][j] = 0;
 }
 }
 while (!q.empty()) {
 const auto node = q.front();
 int x = node.first, y = node.second;
 for (const auto& dir : dirs) {
 int new_x = x + dir[0], new_y = y + dir[1];
 if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= n)
 continue;
 if (scores[new_x][new_y] <= 1 + scores[x][y])
 continue;
 scores[new_x][new_y] = 1 + scores[x][y];
 q.push(make_pair(new_x, new_y));
 }
 q.pop();
 }

 vector<vector<bool>> visited(n, vector<bool>(n, false));
 priority_queue<pair<int, pair<int, int>>> pq;
 pq.push(make_pair(scores[0][0], make_pair(0, 0)));

 while (!pq.empty()) {
 auto node = pq.top();
 pq.pop();
 int safe_factor = node.first;
 auto pos = node.second;
 if (pos.first == n - 1 && pos.second == n - 1)
 return safe_factor;
 visited[pos.first][pos.second] = true;
 for (const auto& dir : dirs) {
 int new_x = pos.first + dir[0], new_y = pos.second + dir[1];
 if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= n)
 continue;

 if (visited[new_x][new_y])
 continue;

 int score = min(safe_factor, scores[new_x][new_y]);
 pq.push(make_pair(score, make_pair(new_x, new_y)));
 visited[new_x][new_y] = true;
 }

 }

 return -1;
 }
};

References

Leetcode

1219. Path with Maximum Gold

Tue, 14 May 2024 20:39:03 +0800

Given a matrix, whose element representing the number of golds. Find a path such that the sum is maximized and without crossing the grids that has not gold elements.

Intuition

Use backtracking to find all possible paths, and update the results.

Approach

We use two variables current and result to store results, current stores the sum of golds from start to current position, result stores the final result.

Complexity

Time complexity: In worst case, each grid contains gold, for each position, there are $\binom{m+n}{m}$ possible paths, so the overall complexity is

$$O\left(mn\binom{m+n}{m}\right)$$

Space complexity: No extra spaces needed (without considering recursive stack)

$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
 void backtracking(vector<vector<int>>& grid, int i, int j, int &current, int &result) {
 if (grid[i][j] <= 0) return;
 current += grid[i][j];
 // update result
 result = max(result, current);
 // mark as visited
 int temp = grid[i][j];
 grid[i][j] = -1;
 for (const auto &dir: dirs) {
 int row = i + dir[0], col = j + dir[1];
 if (row < 0 || row >= grid.size() || col < 0 || col >= grid[0].size()) {
 continue;
 }
 backtracking(grid, row, col, current, result);
 }
 // retrieve the state
 grid[i][j] = temp;
 current -= grid[i][j];
 }

 int getMaximumGold(vector<vector<int>>& grid) {
 int result = 0;
 for (int i = 0; i < grid.size(); ++i) {
 for (int j = 0; j < grid[0].size(); ++j) {
 if (grid[i][j] == 0) continue;
 int current = 0;
 backtracking(grid, i, j, current, result);
 }
 }
 return result;
 }
};

Reference

Leetcode 1219

861. Score After Flipping Matrix

Mon, 13 May 2024 20:52:02 +0800

Given a binary matrix, we can flip one column or one row, the goal is to flip zero or more times such that the sum of the number represented by the rows are maximized.

Intuition

The leading 1s are always important than the trailing 1s. So we make sure that 1 appears before 0s.

Approach

The challenge is to determine when to flip the rows and flip the columns. From the intuition, we know that:

a row is flipped only if its first bit is 0, after flipping, the number becomes larger and cannot be flipped again.
a column is flipped only if the number of 1s are smaller than 0s.

So we flip the rows first and the columns second.

Complexity

Time complexity: iterate matrix twice.
$$ O(mn) $$
Space complexity: no extra space needed.
$$ O(1) $$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 int matrixScore(vector<vector<int>>& grid) {
 int m = grid.size(), n = grid[0].size();
 for (int i = 0; i < m; ++i) {
 if (grid[i][0] == 0) {
 // flip row
 for (int j = 0; j < n; ++j) {
 grid[i][j] = 1 - grid[i][j];
 }
 }
 }

 // check column by column
 for (int j = 1; j < n; ++j) {
 int count = 0;
 for (int i = 0; i < m; ++i) {
 count += grid[i][j];
 }
 if (count < (m + 1) / 2) {
 // flip column
 for (int k = 0; k < m; ++k) {
 grid[k][j] = 1 - grid[k][j];
 }
 }
 }

 int result = 0;
 for (int i = 0; i < m; ++i) {
 for (int j = 0; j < n; ++j) {
 if (grid[i][j] == 0) continue;
 result += (1 << (n - j - 1));
 }

 }

 return result;
 }
};

References

Leetcode

1289. Minimum Falling Path Sum II

Fri, 26 Apr 2024 20:44:17 +0800

Given a matrix, find the minimum falling path sum from top to bottom, with no two adjacent rows sharing the same column.

Intuition

Same as the previous version, we only change the update formula.

Approach

We use dp[i][j] to represent the minimum falling path sum that ends with grid[i][j]. The update rules is then given by

$$ dp[i][j] = \min_{k=1,\dots,n,k\neq j}(grid[i][j] + dp[i - 1][k]) $$

Complexity

Time complexity: We need to iterate all elements of the matrix once, and each iterate requires to iterate its last row once, which is $O(n)$. This can be reduced to $O(n^2\log n)$ by compute the smallest, second smallest elements of the last row.

$$O(n^3)$$

Space complexity: the dp matrix is of size $n\times n$. This can be reduced to $O(n)$ by use a $n\times 2$ matrix since each row only relates to its last row.

$$O(n^2)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Solution {
public:
 int minFallingPathSum(vector<vector<int>>& grid) {
 int n = grid.size();
 vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
 dp[0] = grid[0];
 for (int row = 1; row < n; ++row) {
 for (int col = 0; col < n; ++col) {
 for (int last_col = 0; last_col < n; ++last_col) {
 if (last_col == col) continue;
 dp[row][col] = min(dp[row][col], grid[row][col] + dp[row - 1][last_col]);
 }
 }
 }
 int result = INT_MAX;
 for (int i = 0; i < n; ++i) {
 result = min(result, dp[n - 1][i]);
 }
 return result;
 }
};

Reference

Leetcode 1289

1992. Find All Groups of Farmland

Sat, 20 Apr 2024 15:31:49 +0800

Given a matrix where its grid component representing islands and forests, count the number of farmlands.

Intuition

Start from the top left coordinate of the farmland, Use DFS to find the bottom right coordinate of the farmland.

Approach

We define the possible directions as go_right and go_down respectively, we iterate all grids, if it is an grid of the farmland, then we use DFS to find the bottom right coordinate of the current farmland, and then we mark the farmland as visited and store the coordinates.

Complexity

Time complexity: iterate all grids once
$$O(mn)$$
Space complexity: number of farmlands
$$O(mn)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
 vector<vector<int>> dirs{{0, 1}, {1, 0}};
public:
 void dfs(vector<vector<int>>& land, int i, int j, vector<int> &bottom_right) {
 land[i][j] = 0;
 bool reach_end = true;
 for (const auto &dir: dirs) {
 int row = i + dir[0], col = j + dir[1];
 if (0 <= row && row < land.size() &&
 0 <= col && col < land[0].size() &&
 land[row][col] == 1) {
 reach_end = false;
 dfs(land, row, col, bottom_right);
 }
 }
 if (reach_end && bottom_right.empty()) {
 bottom_right = vector<int>{i, j};
 }
 }

 vector<vector<int>> findFarmland(vector<vector<int>>& land) {
 vector<vector<int>> result;
 for (int i = 0; i < land.size(); ++i) {
 for (int j = 0; j < land[0].size(); ++j) {
 if (land[i][j] == 0) continue;
 vector<int> bottom_right;
 dfs(land, i, j, bottom_right);
 result.push_back(vector<int>{i, j, bottom_right[0], bottom_right[1]});
 }
 }
 return result;
 }
};

200. Number of Islands

Fri, 19 Apr 2024 20:25:03 +0800

Given a matrix where its grid component representing islands and waters, count the number of Islands.

Intuition

Use DFS to find all connected components of the island, then count the number of islands.

Approach

We iterate all grid component, when we meet the land, we use DFS to find all connected components of the island, and mark those connected components as visited.

Complexity

Time complexity: visit all positions once.
$$O(mn)$$
Space complexity:
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
 void dfs(vector<vector<char>>& grid, int i, int j) {
 if (grid[i][j] == '0') return;
 grid[i][j] = '0';
 for (const auto &dir: dirs) {
 if (0 <= i + dir[0] && i + dir[0] < grid.size() &&
 0 <= j + dir[1] && j + dir[1] < grid[0].size()) {
 dfs(grid, i + dir[0], j + dir[1]);
 }
 }
 }

 int numIslands(vector<vector<char>>& grid) {
 int count = 0;
 for (int i = 0; i < grid.size(); ++i) {
 for (int j = 0; j < grid[0].size(); ++j) {
 if (grid[i][j] == '0') continue;
 dfs(grid, i, j);
 ++count;
 }
 }
 return count;
 }
};

463. Island Perimeter

Thu, 18 Apr 2024 20:49:51 +0800

Given a matrix, find the perimeter of the connected grid land

Intuition

Use DFS to find the island, then compute the perimeter.

Approach

We use result to store the result and find all connected components of the island with DFS, to compute the perimeter, to update result, we need to compute how many components that are connected the current component.

Now, note that to prevent infinite recursion, we set grid[i][j] = -1 to mark it visited, then for each component, it may be in three states:

grid[i][j] = 0, it is water
grid[i][j] = 1, it is a component of the island and being unvisited
grid[i][j] = -1, it is a component of the island and has been visited.

Complexity

Time complexity: iterate all grids once.
$$O(mn)$$
Space complexity: no extra space needed
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
 void dfs(vector<vector<int>>& grid, int i, int j, int &result) {
 if (grid[i][j] != 1) return;
 int num_edges = 4;
 grid[i][j] = -1;
 for (const auto&dir: dirs) {
 if (0 <= i + dir[0] && i + dir[0] < grid.size() &&
 0 <= j + dir[1] && j + dir[1] < grid[0].size()) {
 if (grid[i + dir[0]][j + dir[1]] == 0)
 continue;
 --num_edges;
 dfs(grid, i + dir[0], j + dir[1], result);
 }
 }
 result += num_edges;
 }

 int islandPerimeter(vector<vector<int>>& grid) {
 int result = 0;
 for (int i = 0; i < grid.size(); ++i) {
 for (int j = 0; j < grid[0].size(); ++j) {
 if (grid[i][j] == 0) continue;
 dfs(grid, i, j, result);
 }
 }
 return result;
 }
};