Tree on Jiang Yi(姜祎)'s Homepage

834. Sum of Distances in Tree

Mon, 29 Apr 2024 21:24:06 +0800

Given a tree, return a vector, with each elements of the vector is the sum of the distances between the corresponding node and all other nodes.

Intuition

Intuitively, I want to use DFS + memorization to solve the problem, however, such method exceeds te time limit.

Then, I refer to some solutions, and solve the problem.

Approach

DP -> TLE

In the first, I am thinking that we can use dp[i][j] to represent the distance between the node i and the node j. Initially, dp are initialized as follows:

If there is an edge between i and j, then dp[i][j]=dp[j][i]=1.
If there is an edge between i and j, then dp[i][j]=dp[j][i]=INFINITY.

we traversal from node 0 to node n-1, for each node i, we compute the distance between i and all other nodes j. There are two cases:

dp[i][j] != INFINITY, then we directly returns dp[i][j]
dp[i][j] == INFINITY, then it means the distance between node i and node j hasn’t been computed, we then update it as follows:

$$ dp[i][j] = \min_{k\in N(i)} (1 + dp[k][j]) $$

where $N(i)$ is the nodes that adjacent to node i. The min operation is used here since the node k and the node j may not connected (without passing node i).

The code is given as follows. However, the time complexity is $O(n^2)$, which exceeds the time limit.

 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


class Solution {
public:
 int dfs(const vector<vector<int>>& adjs, vector<vector<int>> &dp,
 vector<bool> &visited, int start, int end) {
 if (dp[start][end] != INT_MAX) return dp[start][end];
 if (visited[start]) return INT_MAX;
 visited[start] = true;
 int distance = INT_MAX;
 for (int next_node: adjs[start]) {
 distance = min(distance, dfs(adjs, dp, visited, next_node, end));
 }
 visited[start] = false;
 if (distance != INT_MAX) dp[start][end] = distance + 1;
 return dp[start][end];
 }

 vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges) {
 vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
 vector<vector<int>> adjs(n);
 // initialize the distance matrix
 for (const auto& edge: edges) {
 dp[edge[0]][edge[1]] = 1;
 dp[edge[1]][edge[0]] = 1;
 adjs[edge[0]].push_back(edge[1]);
 adjs[edge[1]].push_back(edge[0]);
 }

 vector<bool> visited(n, false);
 for (int i = 0; i < n; ++i) {
 for (int j = i + 1; j < n; ++j) {
 dfs(adjs, dp, visited, i, j);
 }
 // the graph is undirected
 for (int j = 0; j < i; ++j) {
 dp[i][j] = dp[j][i];
 }
 }

 vector<int> result(n);
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < n; ++j) {
 if (j == i) continue;
 result[i] += dp[i][j];
 }
 }
 return result;
 }
};

Tree + Traversal

The second way is not easy to figure out. We decompose it into two parts:

compute the distance between the root node and all other nodes.
Convert the root node from one to another and update the result.

Sum of distance from root node to all other nodes.

Consider one example tree with root set as 0:

We first define dist[i] as the distance of all child nodes of node i to node i. Then we have:

$dist[i] = 0$ if i is a leaf node.
$dist[i] = \sum_{j\in C(i)}dist[j] + |C(i)|$ if i is not a leaf node, where $C(i)$ is the offspring of node i

We can now compute the sum of distances between root 0 to all other nodes, which is result[0].

Now we need to compute all other results. Repeating the above process is too time consuming, we need to reduce the time complexity. We are seeking a way to compute result[i] from result[j], where $j\in C(i)$.

Note that for $k\in C(j)$, when we compute result[i], we are computing distance from $k$ to $i$, so we need to reduce by 1 since their height decreases (the root changes from i to j). On the other hand, all other nodes, which are not offspring of node j, is added by 1 since the height of them increases. Thus, the transformation reads:

$$ result[j] = result[i] - |C(j)| + n - |C(j)| $$

Complexity

Time complexity: visited all nodes twice.
$$ O(n) $$
Space complexity: use two vectors of size $n$ to store the result.
$$ O(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
36
37
38
39
40
41
42


class Solution {
public:
 void post_order_traversal(const vector<vector<int>>& adjs,
 vector<int>& count, vector<int>& result,
 int node, int parent) {
 for (int next_node : adjs[node]) {
 if (next_node == parent)
 continue;
 post_order_traversal(adjs, count, result, next_node, node);
 count[node] += count[next_node];
 result[node] += count[next_node] + result[next_node];
 }
 ++count[node];
 }

 void pre_order_traversal(const vector<vector<int>>& adjs,
 vector<int>& count, vector<int>& result,
 int node, int parent) {
 for (int next_node : adjs[node]) {
 if (next_node == parent)
 continue;
 result[next_node] =
 result[node] - count[next_node] + count.size() - count[next_node];
 pre_order_traversal(adjs, count, result, next_node, node);
 }
 }

 vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges) {
 vector<int> count(n), result(n);
 vector<vector<int>> adjs(n);
 for (const auto &edge: edges) {
 adjs[edge[0]].push_back(edge[1]);
 adjs[edge[1]].push_back(edge[0]);
 }
 // compute result[0]
 post_order_traversal(adjs, count, result, 0, -1);
 // compute other results from result[0]
 pre_order_traversal(adjs, count, result, 0, -1);

 return result;
 }
};

References

310. Minimum Height Trees

Tue, 23 Apr 2024 21:02:07 +0800

Given a tree, reorganize the tree such that the height of the tree is minimized.

Intuition

We construct the tree from bottom to top, util we find the root of the tree

Approach

We use topological sort to order the nodes of the tree, then we iteratively construct the tree from bottom to top with BFS.

We use a different stop criteria to avoid missing possible solutions.

The result contains at most two possible roots, since if there are three, then the degree of one node must be lower than the other two nodes.

Complexity

Time complexity: iterate all nodes once.
$$O(n)$$
Space complexity: store the adjacent lists.
$$O(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
36
37
38
39
40


class Solution {
public:
 vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
 // boundary check
 if (n == 1) return vector<int>{0};
 vector<vector<int>> adjs(n);
 vector<int> in_degrees(n);
 for (const auto &edge: edges) {
 adjs[edge[0]].push_back(edge[1]);
 adjs[edge[1]].push_back(edge[0]);
 ++in_degrees[edge[0]];
 ++in_degrees[edge[1]];
 }
 // leaf nodes
 queue<int> q;
 for (int i = 0; i < n; ++i) {
 if (in_degrees[i] == 1) q.push(i);
 }
 while (n > 2) {
 // construct next layer
 int size = q.size();
 n -= size;
 for (int i = 0; i < size; ++i) {
 int node = q.front();
 for (int next_node: adjs[node]) {
 if (--in_degrees[next_node] == 1) {
 q.push(next_node);
 }
 }
 q.pop();
 }
 }
 vector<int> result;
 while (!q.empty()) {
 result.push_back(q.front());
 q.pop();
 }
 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;
 }
};

623. Add One Row to Tree

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

Intuition

Just list all nodes with height height - 1 and insert a new layer with the given rules.

Approach

Use a queue to store all nodes with the same height, and use BFS to update the nodes, once we reach the height height - 1, we add a new layer with the given val for each node:

Create a new left child with the given (val, node->left, nullptr)
Create a new right child with the given (val, nullptr, node->right)

Complexity

Time complexity: iterate all nodes of height height - 1
$$O(n)$$
Space complexity: storing all nodes of height height - 1
$$O(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
36
37
38
39


/**
 * 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:
 TreeNode* addOneRow(TreeNode* root, int val, int depth) {
 if (depth == 1) {
 TreeNode* new_root = new TreeNode(val, root, nullptr);
 return new_root;
 }
 queue<TreeNode*> q;
 q.push(root);
 --depth;
 while (--depth) {
 int size = q.size();
 for (int i = 0; i < size; ++i) {
 auto node = q.front();
 if (node->left) q.push(node->left);
 if (node->right) q.push(node->right);
 q.pop();
 }
 }
 while (!q.empty()) {
 auto node = q.front();
 node->left = new TreeNode(val, node->left, nullptr);
 node->right = new TreeNode(val, nullptr, node->right);
 q.pop();
 }
 return root;
 }
};