DFS on Jiang Yi(姜祎)'s Homepage

78. Subsets

Tue, 21 May 2024 22:16:49 +0800

Given an array, find all subsets in the array

Intuition

Use DFS to iterate over all subsets and record them.

Approach

A subset can be represented as a binary number of n digits. Each digit is either 0 or 1. We can use DFS to iterate over all possible such format of binary numbers.

Complexity

Time complexity: iterate all binary numbers of length n once.
$$O(2^n)$$
Space complexity:
$$O(2^n)$$

Code

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


class Solution {
public:
 void dfs(const vector<int>& nums, int index, vector<vector<int>>& result,
 vector<int>& s) {
 if (index == nums.size()) {
 result.push_back(s);
 return;
 }
 // digit is 1
 s.push_back(nums[index]);
 dfs(nums, index + 1, result, s);
 s.pop_back();
 // digit is 0
 dfs(nums, index + 1, result, s);
 }

 vector<vector<int>> subsets(vector<int>& nums) {
 vector<vector<int>> result;
 vector<int> s;
 dfs(nums, 0, result, s);
 return result;
 }
};

Reference

Leetcode

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

514. Freedom Trail

Sat, 27 Apr 2024 11:55:28 +0800

Given a string displaying in the ring format, we can move one character at each step either in clockwise or anticlockwise (or hold still), now we need to retrieve a given string with minimum steps.

Intuition

We can construct a graph from the string and use DFS to search all possible paths, and find the path with minimum steps.

Approach

DFS -> TLE

In the beginning, I am going to use DFS to find all possible paths and find the path with minimum steps.

First, we need construct the graph, each character is adajcent to all other characters in ring, so there are n=length(ring) nodes and (n-1)^n edges. each edge has a weight representing the distance between two characters: weight(i,j)=min(abs(i-j), n - abs(i-j)) (here we use index of the character to represent the node).

Then, we can use DFS to search all possible paths, in each point, we have a state (ring_index, key_index), representing the current index on ring and key, there are two cases:

ring[ring_index] == key[key_index], in this case, we change key_index to key_index+1 and keeps ring_index unchanged (hold still).
ring[ring_index] != key[key_index], in this case, we need to rotate the string ring to make ring[ring_index] == key[key_index], this takes step and notice that there may multiple choices, so we need to go over all of them.

Once key_index == len(key), we have found a path and we can now update the result.

The code is given as follows:

 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


class Solution {
public:
 void dfs(unordered_map<int, vector<vector<int>>> &adjs,
 const string &ring, const string &key,
 int ring_index, int key_index,
 int &min_rotates, int &current_rotates) {
 if (key_index == key.size()) {
 min_rotates = min(min_rotates, current_rotates);
 return;
 }

 // character matches
 if (ring[ring_index] == key[key_index]) {
 dfs(adjs, ring, key, ring_index, key_index + 1, min_rotates, current_rotates);
 return;
 }
 // character doesn't match
 for (const auto &next_node: adjs[ring_index]) {
 int next_ring_index = next_node[0], rotates = next_node[1];
 if (ring[next_ring_index] != key[key_index]) continue;
 current_rotates += rotates;
 dfs(adjs, ring, key, next_ring_index, key_index, min_rotates, current_rotates);
 current_rotates -= rotates;
 }
 }

 int findRotateSteps(string ring, string key) {
 unordered_map<int, vector<vector<int>>> adjs;
 int n = ring.size();
 for (int i = 0; i < ring.size(); ++i) {
 for (int j = 0; j < ring.size(); ++j) {
 if (j == i) continue;
 int diff = abs(i - j);
 int rotates = min(diff, n - diff);
 adjs[i].push_back(vector<int>{j, rotates});
 }
 }

 int ring_index = 0, key_index = 0;
 int min_rotates = INT_MAX, current_rotates = 0;
 dfs(adjs, ring, key, ring_index, key_index, min_rotates, current_rotates);
 int spell = key.size();
 return min_rotates + spell;
 }
};

Dynamic programming

The problem of DFS is that, its time complexity grows exponentially if there have multiple repeat characters, which causes TLE (time limit exceeded) error.

So, to reduce the complexity, we can construct the solution from bottom to up. That is, we remember the path to go from the current state, and now we now go one step back, util we back to the original state.

We use dp[i][j] to represent start from ring[j], the minimum rotate steps we need to recover the string key[i...m], where m=length(key), the target then becomes finding out dp[0][0].

Note that we can easily compute dp[m-1][j], j=1,\dots,n, since there is only one character we need to recover, so we start from ring[j], and rotate util we find a character ring[k] such that ring[k]==key[m-1], the minimum steps is then updated. The update formula is then given by

$$ dp[i][j] = \min_{k=1,\dots,n,\ ring[k]=key[i]}(dp[i][j],\ dp[i + 1][k] + step(j, k)) $$

where $step(j,k)=\min(|j-k|,\ n-|j-k|)$.

Complexity

Time complexity: The dp matrix is of size $m\times n$, and each time, we need to iterate over the ring once.
$$O(mn^2)$$
Space complexity:The dp matrix is of size $m\times n$
$$O(mn)$$

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 findRotateSteps(string ring, string key) {
 int m = key.size(), n = ring.size();
 vector<vector<int>> dp(m + 1, vector<int>(n));
 for (int i = m - 1; i >= 0; --i) {
 // start from ring[j]
 for (int j = 0; j < n; ++j) {
 dp[i][j] = INT_MAX;
 // Find the feasible target ring[k] == key[i]
 for (int k = 0; k < n; ++k) {
 if (ring[k] != key[i])
 continue;
 int rotates = min(abs(k - j), n - abs(k - j));
 dp[i][j] = min(dp[i][j], dp[i + 1][k] + rotates);
 }
 }
 }
 return dp[0][0] + m;
 }
};

Reference

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

988. Smallest String Starting From Leaf

Wed, 17 Apr 2024 21:15:03 +0800

Given a binary tree with value on each node representing a lowercase letter, find the lexicographically smallest string starting from the leaf to root node

Intuition

We use DFS to find all strings from the root node to the leaf nodes, then reverse the string and compare it withe the largest string.

Approach

We use current to represent the string starting from the root node to the current node and we use result to store the currently best result. When we reach the leaf node, we compare the current with result and update result.

Complexity

Time complexity: iterate all nodes once.
$$O(n)$$
Space complexity: the string is related to the height of the tree.
$$O(\log n)$$

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


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 void dfs(TreeNode* root, string &current, string &result) {
 current.push_back('a' + root->val);
 // leaf node
 if (!root->left && !root->right) {
 // update result
 reverse(current.begin(), current.end());
 if (current < result) result = current;
 reverse(current.begin(), current.end());
 } else {
 if (root->left) dfs(root->left, current, result);
 if (root->right) dfs(root->right, current, result);
 }
 current.pop_back();
 }

 string smallestFromLeaf(TreeNode* root) {
 string result(8501, 'z');
 string current;
 dfs(root, current, result);
 return result;
 }
};

129. Sum Root to Leaf Numbers

Sun, 14 Apr 2024 21:06:34 +0800

concatenate the digit of path from the root to the leaf, and sum over the concatenated numbers.

Intuition

Use DFS to find all the paths, use a num variable to store the number concatenated, then sum over num.

Approach

We use num to represent the number from the root to the current node, if the current node is a leaf node, we add num to sum. Finally, we return sum as the result.

Complexity

Time complexity: iterate all nodes once.
$$O(n)$$
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
27
28
29
30
31
32
33
34


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 void dfs(TreeNode *root, int &sum, int &num){
 if (!root) {
 return;
 }
 num = num * 10 + root->val;
 if (!root->left && !root->right){
 sum += num;
 }else{
 dfs(root->left, sum, num);
 dfs(root->right, sum, num);
 }
 num /= 10;
 }

 int sumNumbers(TreeNode* root) {
 int sum = 0;
 int num = 0;
 dfs(root, sum, num);
 return sum;
 }
};

404. Sum of Left Leaves

Sun, 14 Apr 2024 21:06:34 +0800

Given the root of a binary tree, return the sum of all left leaves.

Intuition

Use DFS to iterate over all nodes, if it is a left leaf, sum it to the result.

Approach

For every node, we care about one thing: whether its left child is a leaf node or not. If it is, then we add it.

Complexity

Time complexity: iterate all nodes once.
$$ O(n) $$
Space complexity: Store the sum.
$$ 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


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 bool is_leaf_node(TreeNode* node) {
 if (!node) return false;
 return !(node->left || node->right);
 }

 int sumOfLeftLeaves(TreeNode* root) {
 if (!root) return 0;
 int result = 0;
 if (is_leaf_node(root->left)) {
 result += root->left->val;
 }
 result += sumOfLeftLeaves(root->right);
 result += sumOfLeftLeaves(root->left);
 return result;
 }
};