Hard on Jiang Yi(姜祎)'s Homepage

664. Strange Printer

Wed, 21 Aug 2024 15:16:41 +0000

Approach

We can use a dp matrix, where element dp[i][j] represents the minimum turn to print substring s[i...j].

Then, there are two cases:

case 1: We print s[i] separately, now we have dp[i][j] = 1 + dp[i + 1][j].
case 2: There is a char s[k] == s[i], then the string s[i...k] can be obtained by printing some new substrings on the range s[i...k], now we have dp[i][j] = dp[i][k-1]+dp[k+1][j]

Combining case 1 and case 2, we can now write the update formula for dynamic programming:

1
2
3
4


dp[i][j] = 1 + dp[i + 1][j];
for (int k = i + 1; k <= j; ++k) {
 dp[i][j] = min(dp[i][j], dp[i][k-1] + dp[k+1][j]);
}

the base case is when i > j, d[pi][j] = 0 and when i=j, dp[i][j] = 1.

Complexity

Time complexity: iterate the matrix once, each iteration takes $O(n)$ time.
$$O(n^3)$$
Space complexity: use a dp matrix of size $n\times n$ to store the result
$$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


class Solution {
public:
 int dfs(vector<vector<int>> &dp, int start, int end, const string &s) {
 if (start > end) return 0;
 if (start == end) return 1;
 if (dp[start][end] != -1) return dp[start][end];

 int ans = 1 + dfs(dp, start + 1, end, s);
 for (int k = start + 1; k <= end; ++k) {
 if (s[k] != s[start]) continue;
 ans = min(ans, dfs(dp, start, k - 1, s) + dfs(dp, k + 1, end, s));
 }
 dp[start][end] = ans;
 return ans;
 }

 int strangePrinter(string s) {
 int n = s.size();
 vector<vector<int>> dp(n, vector<int>(n, -1));
 return dfs(dp, 0, n - 1, s);
 }
};

References

Leetcode 664

3068. Find the Maximum Sum of Node Values

Thu, 09 May 2024 20:21:07 +0800

Given a graph and an integer $k$, where the nodes represent values, we can choose an edge, and perform XOR operations on its nodes corresponding to $k$. The goal is the find the maximum sum of the values after 0 or more XOR operations.

Intuition

Since XOR operations satisfies the property that a XOR b XOR b = a, we can record the gain after XOR operation on an edge and finally obtain the result.

Approach

We use total_sum to record the sum of the values of the original trees.

Then for each node, we perform the XOR operation and record the change if the change > 0, and this change requires one operation, which we add to count. Meanwhile, we use positive_min and negative_max to record the minimum absolute change for reverting use.

Now after all nodes are computed, we need to compute the result.

If count is even, it means the operations satisfied the requirement that the nodes of an edge changes simultaneously
If count is odd, then there is one invalid operation and we need to revert the operation. To make the final sum maximum, we can either subtract the positive_min or add negative_max, the result is then obtained by taking the maximum of them.

Complexity

Time complexity: iterate the array once.
$$O(n)$$
Space complexity: No extra spaces are 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


class Solution {
public:
 long long maximumValueSum(vector<int>& nums, int k,
 vector<vector<int>>& edges) {
 long long total_sum = 0;
 int count = 0;
 int positive_min = INT_MAX, negative_max = INT_MIN;
 for (int num : nums) {
 int new_num = num ^ k;
 total_sum += num;
 int change = new_num - num;
 if (change > 0) {
 positive_min = min(positive_min, change);
 total_sum += change;
 ++count;
 } else {
 negative_max = max(negative_max, change);
 }
 }

 if (count % 2 == 0)
 return total_sum;
 return max(total_sum - positive_min, total_sum + negative_max);
 }
};

Reference

Leetcode

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

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

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