LeetCode on Jiang Yi(姜祎)'s Homepage

592. Fraction Addition and Subtraction

Fri, 23 Aug 2024 20:16:54 +0800

Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.

Intuition

Simulate the calculation of fraction addition and subtraction process.

Approach

First, to simplify addition and subtraction, we move the - to numerator part, for example, 3/4-2/3 becomes 3/4+(-2)/3, this step makes all operations become addition.

Second, we use a initial value 0/1 to record result to prevent from parsing the first fraction. Thus 3/4-2/3 is actually equivalent to 0/1+3/4-2/3.

Now, in each loop, we record the sign, the numerator, the denominator. Then we compute the result with the previous result with the formula

$$ \frac{a}{b} + \frac{c}{d} = \frac{ad-bc}{bd} $$

after computation, we use gcd() function to make the resulted fraction irreducible.

Complexity

Time complexity: Iterate the string once.
$$O(n)$$
Space complexity: No extra spaces 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
40
41
42
43
44
45
46
47


class Solution {
public:
 string fractionAddition(string expression) {
 int n = expression.size();
 int numerator1 = 0, dominator1 = 1;
 int numerator2 = 0, dominator2 = 1;
 int sign = 1;
 for (int i = 0; i < n;) {
 if (expression[i] == '-') {
 sign = -1;
 ++i;
 continue;
 }
 if (expression[i] == '+') {
 sign = 1;
 ++i;
 continue;
 }
 numerator2 = 0;
 while (i < n && '0' <= expression[i] && expression[i] <= '9') {
 numerator2 = numerator2 * 10 + (expression[i] - '0');
 ++i;
 }
 numerator2 *= sign; // move sign to numerator
 sign = 1; // reset sign
 ++i; // division operator
 dominator2 = 0;
 while (i < n && '0' <= expression[i] && expression[i] <= '9') {
 dominator2 = dominator2 * 10 + (expression[i] - '0');
 ++i;
 }
 numerator1 = (numerator1 * dominator2 + numerator2 * dominator1);
 dominator1 = dominator1 * dominator2;
 if (numerator1 && dominator1) {
 int gcd_num = gcd(numerator1, dominator1);
 numerator1 = numerator1 / gcd_num;
 dominator1 = dominator1 / gcd_num;
 }
 }
 // corner case
 if (numerator1 == 0) {
 return "0/1";
 }

 return to_string(numerator1) + "/" + to_string(dominator1);
 }
};

Reference

leetcode 592

506. Relative Ranks

Thu, 22 Aug 2024 21:36:01 +0800

Given an integer, flip all bits in its binary representation.

Intuition

Use XOR operation to complete this task.

Approach

We can use the XOR operation to complete this task. However, notice that we cannot simply use num ^ INT_MAX since the leading 1s are still 1s if num is too small. Instead, we need to compute the number of digits in num, and use the corresponding masks.

Notice that if 2^30 < num <= 2^31-1, in this case the corresponding mask will exceeds the integer ranges, thus we use INT_MAX directly in this case.

Complexity

Time complexity: Compute the digits of a number.
$$O(\log n)$$
Space complexity: No extra spaces needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int findComplement(int num) {
 int num_bits = 0;
 int temp = num;
 while (temp) {
 temp >>= 1;
 ++num_bits;
 }
 if (num_bits == 31) {
 return num ^ INT_MAX;
 }
 int mask = (1 << num_bits) - 1;
 return num ^ mask;
 }
};

Reference

leetcode 476

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

264. Ugly Number II

Sun, 18 Aug 2024 10:37:20 +0000

A number is ugly if its prime factors is a subset of $\{2, 3, 5\}$. We are required to find the $n$-th ugly number

Intuition

Each ugly number is generated from a previous ugly number by multiplying $2$, $3$ or $5$.

Approach

We use three pointers index_2, index_3 and index_5 to record the index of previous ugly number. For example, $4$ is generated from $2$ by multiplying $2$, so the index index_2 is the index of 2.

Then, we take the minimum of three generated numbers:

1

dp[i] = min(dp[index_2] * 2, dp[index_3] * 3, dp[index_5] * 5)

Finally, we need to update the pointers so that there is no duplication.

Complexity

Time complexity: iterate once.
$$O(n)$$
Space complexity: Use a vector 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


class Solution {
public:
 int nthUglyNumber(int n) {
 vector<int> result{1};

 int index_2 = 0, index_3 = 0, index_5 = 0;

 for (int i = 1; i < n; ++i) {
 int result_2 = result[index_2] * 2;
 int result_3 = result[index_3] * 3;
 int result_5 = result[index_5] * 5;
 int current_ugly_num = min(result_2, min(result_3, result_5));

 if (current_ugly_num == result_2) ++index_2;
 if (current_ugly_num == result_3) ++index_3;
 if (current_ugly_num == result_5) ++index_5;
 }

 return result;
 }
};

References

Leetcode 264

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

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

786. K-th Smallest Prime Fraction

Fri, 10 May 2024 22:39:54 +0800

Given an integer array of size $n$ containing prime integers, it can form $n(n-1)/2$ fractions, we are required to find the $k$-th smallest prime fraction.

Intuition

We can use a priority queue to store prime integers, then we maintain the priority queue.

Approach1: Brute force

Complexity

Time complexity: iterate the array once and maintain the priority queue.
$$O(n^2\log k)$$
Space complexity: the size of the priority queue
$$O(k)$$

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 {
 class Compare {
 public:
 bool operator()(const vector<int>& a, const vector<int>& b){
 return 1.0 * a[0] / a[1] < 1.0 * b[0] / b[1]; // the root is the biggest
 }
 };
public:
 vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
 priority_queue<vector<int>, vector<vector<int>>, Compare> pq;
 int n = arr.size();
 for (int r = 1; r <= k + 1; ++r) {
 for (int i = 0; i < n; ++i) {
 if (i + r >= n) break;
 pq.push(vector<int>{arr[i], arr[i + r]});
 if (pq.size() > k) {
 pq.pop();
 }
 }
 }
 return pq.top();
 }
};

Approach2: Simplification

Notice that Approach1 requires iterating over all fractions, can we reduce the time complexity?

The solution is by considering the relative order, if we write a matrix whose element a[i][j]=nums[i]/nums[j] (i<j), then we know that a[i][i+1]>...>a[n-1][n] since the array nums are increasing. So, the smallest fraction are in a[1][2], ..., a[n-1][n]. If we take the smallest fraction, and add its successive elements (same column, last row), then we can find the second smallest fraction and so on. This solution requires iterating over $\max(n, k)$ fractions and $O(n)$ spaces.

Complexity

Time complexity: iterate $\max(n, k)$ elements and maintain the priority queue.
$$O(\max(n, k)\log n)$$
Space complexity: the size of the priority queue
$$O(n)$$

Code

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


class Solution {
public:
 vector<int> kthSmallestPrimeFraction(vector<int>& A, int K) {
 // (fraction, (i, j))
 priority_queue<pair<double, pair<int, int>>> pq;
 for (int i = 0; i < A.size(); ++i) {
 pq.push({-1.0 * A[i] / A.back(), {i, A.size() - 1}});
 }
 while (--K) {
 auto t = pq.top().second;
 q.pop();
 --t.second;
 pq.push({-1.0 * A[t.first] / A[t.second], {t.first, t.second}});
 }
 return {A[pq.top().second.first], A[pq.top().second.second]};
 }
};

Reference

leetcode

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

3075. Maximize Happiness of Selected Children

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

Given an integer array representing the happiness of the children, select $k$ children such that the sum of their happiness is maximized.

Intuition

Since happiness of all rest children after choosing one child will decrease by 1, their relative order will still the same. So this problem is actually requiring us to select $k$ most happy children.

Approach

Use sorting.

Complexity

Time complexity: Sort the array.
$$O(n\log n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 long long maximumHappinessSum(vector<int>& happiness, int k) {
 sort(happiness.begin(), happiness.end());
 int n = happiness.size();
 long long result = 0;
 for (int i = 0; i < k; ++i) {
 result += max(happiness[n - 1 - i] - i, 0);
 }
 return result;
 }
};

Reference

Leetcode

506. Relative Ranks

Wed, 08 May 2024 20:17:53 +0800

Given an array of scores, assign different ranks based on their position in the sorted array

Intuition

Sort the array and assign based on the sorted array.

Approach

in C++, we can use the property of the container map to solve this problem, the map is constructed so that the key is the score and the value is the index of the score.

Complexity

Time complexity: construct the map
$$O(n\log n)$$
Space complexity: store the scores and indexes
$$O(n)$$

Code

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


class Solution {
public:
 vector<string> findRelativeRanks(vector<int>& score) {
 map<int, int> m;
 for (int i = 0; i < score.size(); ++i) {
 m[score[i]] = i;
 }
 vector<string> result(score.size());
 int index = 1;
 for (auto iter = m.rbegin(); iter != m.rend(); ++iter, ++index) {
 if (index == 1) result[iter->second] = "Gold Medal";
 else if (index == 2) result[iter->second] = "Silver Medal";
 else if (index == 3) result[iter->second] = "Bronze Medal";
 else result[iter->second] = to_string(index);
 }
 return result;
 }
};

Reference

leetcode 506

2487. Remove Nodes From Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list, we are required to remove some nodes, such that for each node in the result linked list, the value of the node is the greatest from the node to the end of the linked list.

Intuition

We construct the result linked list from right to left, that is, the last node in the linked list is kept, then the pointer goes from right to left util there is a node with greater value. This process can be done via post traversal as tree.

Complexity

Time complexity: iterate the list once.
$$O(n)$$
Space complexity: use a set to store numbers.
$$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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 void reverse_traversal(ListNode* head, stack<int> &s) {
 if (!head) return;
 reverse_traversal(head->next, s);
 if (s.empty() || head->val >= s.top()) {
 s.push(head->val);
 }
 }

 ListNode* removeNodes(ListNode* head) {
 stack<int> s;
 reverse_traversal(head, s);
 ListNode* dummyhead = new ListNode(0, nullptr);
 ListNode* cur = dummyhead;
 while (!s.empty()) {
 cur->next = new ListNode(s.top(), nullptr);
 cur = cur->next;
 s.pop();
 }
 return dummyhead->next;
 }
};
``

# References
- [Leetcode](https://leetcode.com/problems/remove-nodes-from-linked-list/description/)

2816. Double a Number Represented as a Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list representing a non-negative integer, we are required to double this integer and convert it back to a linked list.

Intuition

We can just simulate the process, that is:

Retrieve the integer represented by the linked list
Double the integer
Construct the result linked list from the result integer.

Approach

We can just simulate the process as above. However, if the integer is very large, retrieve the integer may cause overflow. To simplify this process, we can use a stack to store the digits of the original integer, then we double the integer by operating on the top of the stack.

In each step, we pop an element from the stack, doubling it and adding it with the carry digit. Then we construct the result linked list with inserting the new node in the front of the head.

Complexity

Time complexity: iterate all digits twice.
$$O(n)$$
Space complexity: store the result linked list.
$$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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* doubleIt(ListNode* head) {
 stack<int> s;
 ListNode* cur = head;
 while (cur) {
 s.push(cur->val);
 cur = cur->next;
 }
 int carry = 0;
 while (!s.empty()) {
 int num = s.top() * 2 + carry;
 ListNode* pre = new ListNode(num % 10, cur);
 carry = num / 10;
 cur = pre;
 s.pop();
 }
 if (carry) {
 ListNode* pre = new ListNode(carry, cur);
 cur = pre;
 }
 return cur;
 }
};

References

Leetcode

237. Delete Node in a Linked List

Sun, 05 May 2024 20:13:45 +0800

Given a linked list and the node to be deleted, delete the node without accessing the head of the linked list

Intuition

This deletion is same as deleting a node from an array.

Approach

We use two pointers, pre and node to represent the previous and current node of the linked list, and we update the value of pre and node at each iteration. Finally, we delete the last node in the linked list.

Complexity

Time complexity: iterate the linked list once.
$$O(n)$$
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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 void deleteNode(ListNode* node) {
 ListNode* pre = nullptr;
 while (node->next) {
 node->val = node->next->val;
 pre = node;
 node = node->next;
 }
 pre->next = nullptr;
 }
};

References

Leetcode

881. Boats to Save People

Sat, 04 May 2024 09:06:48 +0800

Given an array weight where weight[i] representing the weight of person i, now given the capacity of the boat and the constraint that each boat can carry at most two people, find the minimum number of boats to carry all people.

Intuition

Always pair the lightest person abd the heaviest person to a boat.

Approach

We first sort the array weight in ascending order. Then we use two pointers left=0 and right=n-1 to iterate through the array. In each step, there are two cases:

If weight[left]+weight[right] > limit, then we cannot find a peer who can take one boat with right, in this case, right occupies a single boat alone.
If weight[left]+weight[right] <= limit, then these two people can take one boat.

Complexity

Time complexity: sort the array and iterate the array once.
$$ O(n\log n) $$
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


class Solution {
public:
 int numRescueBoats(vector<int>& people, int limit) {
 sort(people.begin(), people.end());
 int left = 0, right = people.size() - 1;
 int num = 0;
 while (left <= right){
 if (people[right] + people[left] <= limit)
 ++left;
 --right;
 ++num;
 }

 return num;
 }
};

References

Leetcode

165. Compare Version Numbers

Fri, 03 May 2024 15:13:23 +0800

Given two strings containing digits and dot, compare them in the form of a version number.

Intuition

Since the leading zeros are required to be ignored, we use dot character as separator and compute the integer of each part and compare them individually.

Approach

We use two index i and j to iterate over s1 and s2, we move the index i to the next dot character and compute the integer num1 we have found. Same operations for j to obtain the integer num2. Then num1 and num2 are compared.

Complexity

Time complexity: iterate each string once.
$$O(n)$$
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


class Solution {
public:
 int compareVersion(string version1, string version2) {
 int i = 0, j = 0;
 int m = version1.size(), n = version2.size();
 while (i < m || j < n) {
 int num1 = 0, num2 = 0;
 while (i < m && version1[i] != '.') {
 num1 = 10 * num1 + (version1[i++] - '0');
 }
 while (j < n && version2[j] != '.') {
 num2 = 10 * num2 + (version2[j++] - '0');
 }
 if (num1 < num2) return -1;
 if (num1 > num2) return 1;
 ++i, ++j;
 }
 return 0;
 }
};

References

Leetcode

1915. Number of Wonderful Substrings

Thu, 02 May 2024 10:51:29 +0800

Given a string ,count the number of wonderful substrings, where a wonderful string is a string that at most one character appears in an odd number of times.

Intuition

We use the prefix sum and bitwise representation to solve the problem. The idea is that every string can be represented by a state, and we can count the number of wonderful substrings by performing operations among states

Approach

According to the hint and the problem description, we have:

there are $10$ possible variables, which represent a to j
we only care about if the variable appears in odd number of times or in even number of times, which means that each variable has $2$ possible states.

so the number of overall possible states is $2^10=1024$. We define the prefix substring as prefix[i] = s[1...i].

For each substring, we can represent the state of the prefix as an index of the array, that is, state(prefix[i]) is a number between 0 and 1023, with each byte representing if the corresponding character appears in odd number of times (1) or in even number of times (0). A wonderful string is then defined as a string whose state representation is 0 or a power of 2.

now the substring s[i...j] is defined as prefix[j]-prefix[i], in state representations, there are three cases:

if one character appears in odd number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 1) -> 0
if one character appears in even number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (0, 0) -> 0
If one character appears in even number of times in one prefix substring, and appears in odd number of times in the other prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 0) -> 1

so, according to analysis, the minus operation in string corresponding to the XOR operation in states. That is, the state of s[i...j] is given by state(s[i...j])=state(prefix[j]) XOR state(prefix[i]).

Note that there is also a simplification since if a XOR b = c, then a XOR c = b. Instead of using a for loop to compute all substrings that ended with character j:

1
2
3
4
5


for (int i = 0; i <j; ++i) {
 // substring s[i...j]
 int substr_state = state[j] ^ state[i];
 // check if substr is a wonderful substring
}

with the property of XOR, wo directly check if state(prefix[j]) XOR 2^k exists, that is:

1
2
3
4


for (int i = 0; i < 10; ++i) {
 int state = state[j] ^ (1 << i);
 // check if state exists and add them.
}

Complexity

Time complexity: iterate string once
$$O(n)$$
Space complexity: stores the state representation.
$$O(1)$$

Code

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


class Solution {
public:
 long long wonderfulSubstrings(string word) {
 vector<int> bits(1024);
 bits[0] = 1;
 long long result = 0;
 int prefix = 0;
 for (char c: word) {
 prefix ^= 1 << (c - 'a');
 result += bits[prefix];
 for (int i = 0; i < 10; ++i) {
 result += bits[prefix ^ (1 << i)];
 }
 ++bits[prefix];
 }
 return result;
 }
};

References:

Leetcode

2441. Largest Positive Integer That Exists With Its Negative

Thu, 02 May 2024 10:28:05 +0800

Given a list containing integers, find the largest positive integer that its negative also exists in the list.

Intuition

There are two ways to solve the problem.

One way is to use two sum, we find the all pairs of integers such that their sum is zero and the one is the negative of the other.
The second way is to use two pointer, we move left and right pointer utils their absolute values are equal.

Approach 1: two sum

Similar to Two Sum, for each num in nums, we store its negative -num in the hash table, however, notice that the added term can be determined by num, we can use a set instead.

Complexity

Time complexity: iterate the list once.
$$O(n)$$
Space complexity: use a set to store numbers.
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 int findMaxK(vector<int>& nums) {
 set<int> s;
 int result = -1;
 for (int num: nums) {
 if (s.find(-num) != s.end()) {
 result = max(result, abs(num));
 } else {
 s.insert(num);
 }
 }
 return result;
 }
};

Approach 2: two pointer

We first sort the lists, then we use left=0 and right=length(nums) pointer to iterate the list, there are three cases:

if nums[left] == -nums[right], then we directly return nums[right] since this is the largest one (note that the list is sorted)
if nums[left] < -nums[right], then we update left to left + 1 since (nums[left], -nums[left]) cannot be found in the list.
if nums[left] > -nums[right], then we update right to right - 1 since (-nums[right], nums[right]) cannot be found in the list.

Complexity

Time complexity: sort the array and iterate the list once.
$$O(n\log 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


class Solution {
public:
 int findMaxK(vector<int>& nums) {
 sort(nums.begin(), nums.end());
 int left = 0, right = nums.size() - 1;
 while (left <= right) {
 if (nums[left] == -nums[right]) return nums[right];
 else if (nums[left] < -nums[right]) ++left;
 else --right;
 }
 return -1;
 }
};
``

# References
- [Leetcode](https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/description/)
- [Leetcode Two Sum](https://leetcode.com/problems/two-sum/)

2000. Reverse Prefix of Word

Wed, 01 May 2024 09:01:22 +0800

Given a string ans a specified character, reverse the prefix that is ended with the specified character.

Intuition

Simulate the process.

Approach

find the first occurrence of the specified character, then reverse the prefix.

Complexity

Time complexity: find the first occurrence of the specified character.
$$O(n)$$
Space complexity: no extra spaces are needed.
$$O(1)$$

Code

1
2
3
4
5
6
7
8
9


class Solution {
public:
 string reversePrefix(string word, char ch) {
 auto pos = word.find(ch);
 if (pos == word.npos) return word;
 reverse(word.begin(), word.begin() + pos + 1);
 return word;
 }
};

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

2997. Minimum Number of Operations to Make Array XOR Equal to K

Mon, 29 Apr 2024 21:16:53 +0800

Given an integer array, we can flip one bit of one element of the array at every step, we asked to compute the minimum flips, such that the XOR of all elements of the array is equal to the given integer $k$.

Intuition

XOR of multiple bits is always equal to either 1 or 0, and changes one of the input bits will cause the result change to the other one.

Approach

We first compute the XOR of all elements of the array, then we compare bit by bit with the XOR result and the given k, utils all bits becomes the same.

Complexity

Time complexity: compute the XOR result
$$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
26
27
28
29
30
31
32
33


class Solution {
public:
 int minOperations(vector<int>& nums, int k) {
 int result = nums[0];
 for (int i = 1; i < nums.size(); ++i) {
 result ^= nums[i];
 }
 vector<int> bits_result, bits_k;
 while (k) {
 bits_k.push_back(k % 2);
 k /= 2;
 }
 while (result) {
 bits_result.push_back(result % 2);
 result /= 2;
 }
 int count = 0;
 int i = 0;
 for (; i < bits_result.size() && i < bits_k.size(); ++i) {
 if (bits_result[i] != bits_k[i])
 ++count;
 }
 for (; i < bits_result.size(); ++i) {
 if (bits_result[i] == 1)
 ++count;
 }
 for (; i < bits_k.size(); ++i) {
 if (bits_k[i] == 1)
 ++count;
 }
 return count;
 }
};

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

2370. Longest Ideal Subsequence

Thu, 25 Apr 2024 20:34:06 +0800

Given a string consisting of lower-case characters, find the longest subsequence such that the distance between adjacent characters in the subsequence are less than a given threshold.

Intuition

Same as the longest increasing subsequence, we can use dynamic programming to solve this problem.

Approach

We use dp[i] to represent the longest ideal subsequence that ended with s[i - 1]. We then update the dp[i] with the property of ideal subsequence:

$$ dp[i] = \max_{j=1,\dots,i-1, \mathrm{abs}(s[i - 1]-s[j - 1])\leq k}(dp[i],\ dp[j] + 1) ,\ i=1,\dots,n$$

However, it turns out that the above solution is of complexity $O(n^2)$, which leads to Time Exceed Limit, so we need to optimize it.

Now, consider the property of ideal sequence, we only care about those characters that is within the range (s[i - 1] - k, s[i - 1] + k). So, we can use a map record, whose key is all lowercase characters, to remember the result that is used to update dp[i], that is, for given index i:

$$ record[l] = \max_{j=1,\dots,i - 1, s[j] - 'a' = l}dp[j] $$

in this way, we have

$$ dp[i] = \max_{\mathrm{abs}((s[i]-'a') - l)\leq k}(dp[i],\ record[l] + 1),\ i=1,\dots,n $$

notice that len(record)=26, so the complexity now reduces to $O(n)$.

Complexity

Time complexity: iterate all characters once, each iteration queries record at most $26$ times.
$$O(n)$$
Space complexity: stores the dp array, can be optimized to $O(1)$ by update result at each iteration.
$$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


class Solution {
public:
 int longestIdealString(string s, int k) {
 int n = s.size();
 vector<int> dp(n + 1);
 vector<int> record(26);
 for (int i = 0; i < n; ++i) {
 dp[i + 1] = 1;
 int index = s[i] - 'a';
 for (int j = 0; j < 26; ++j) {
 if (abs(index - j) <= k) {
 dp[i + 1] = max(dp[i + 1], record[j] + 1);
 }
 }
 record[index] = max(record[index], dp[i + 1]);
 }
 int result = 0;
 for (int i = 0; i < n + 1; ++i) {
 result = max(result, dp[i]);
 }
 return result;
 }
};

1137. N-th Tribonacci Number

Wed, 24 Apr 2024 18:53:26 +0800

Compute the $n$-th tribonacci number.

Intuition

Same as compute the $n$-th fibonacci number, we use three numbers to remember the state.

Approach

We use three numbers to represent $n-2$, $n-1$ and $n$-th tribonacci number respectively

Complexity

Time complexity:
$$O(n)$$
Space complexity:
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Solution {
public:
 int tribonacci(int n) {
 vector<int> nums{0, 1, 1};
 if (n < 3) return nums[n];
 for (int i = 2; i < n; ++i) {
 int temp = nums[2];
 nums[2] += nums[0] + nums[1];
 nums[0] = nums[1];
 nums[1] = temp;
 }
 return nums[2];
 }
};

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

752. Open the Lock

Mon, 22 Apr 2024 19:01:23 +0800

Given a four-digit string, change one digit (plus or minus 1) at a time, find the minimum number of steps to go from the source to target without passing through invalid states.

Intuition

We can image this as a graph path finding problem, where we need to find a path from the source to the target with the minimum number of steps.

Approach

We use BFS to solve this problem. The graph is constructed as follows: each possible state is a node of the graph, such as "1234", "4567", each operation defines an edge between two nodes, for example, we can rotate third digit of "1234" to obtain "1244", since there are two possible directions and four digits, each node has $2^4=16$ adjacent nodes. We keep track of visited nodes and add them to deadends since there are no difference between them.

Complexity

Time complexity: there are at most $10^4=10000$ nodes and we visited all nodes at most once.
$$O(1)$$
Space complexity: there are at most $10^4=10000$ nodes.
$$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
40
41
42
43
44
45
46
47
48
49


class Solution {
public:
 vector<string> get_ajacent_nodes(const string &s) {
 vector<string> result;
 for (int i = 0; i < s.size(); ++i) {
 string s1 = s;
 string s2 = s;
 if ('1' <= s[i] && s[i] <= '9') {
 s1.replace(i, 1, string(1, s[i] + 1));
 s2.replace(i, 1, string(1, s[i] - 1));
 } else if (s[i] == '9') {
 s1.replace(i, 1, "0");
 s2.replace(i, 1, "8");
 } else {
 s1.replace(i, 1, "1");
 s2.replace(i, 1, "9");
 }
 result.push_back(s1);
 result.push_back(s2);
 }
 return result;
 }

 int openLock(vector<string>& deadends, string target) {
 unordered_set<string> set_deadends(deadends.begin(), deadends.end());
 queue<string> q;
 q.push("0000");
 int result = 0;
 while (!q.empty()) {
 int size = q.size();
 for (int i = 0; i < size; ++i) {
 string node = q.front();
 q.pop();
 // dead end check
 if (set_deadends.find(node) != set_deadends.end()) continue;
 // target check
 if (node == target) return result;
 // mark as visited
 set_deadends.insert(node);
 const vector<string> &adjacent_nodes = get_ajacent_nodes(node);
 for (const string &adjacent_node: adjacent_nodes) {
 q.push(adjacent_node);
 }
 }
 ++result;
 }
 return -1;
 }
};

1971. Find if Path Exists in Graph

Sun, 21 Apr 2024 10:51:46 +0800

Find a available path from a given source to a given destination in a given graph.

Intuition

Use DFS to find all reachable nodes and check if the destination lie within those nodes.

Approach

We first transform the adjacency matrix to adjacency list to make BFS easier, then we use a queue to maintain the reachable nodes, to prevent from cycling, we also use a set to keep track of visited nodes. If at any point, we reach the destination, we return directly.

Complexity

Time complexity: iterate all nodes at most once
$$O(n)$$
Space complexity: stores nodes of the same distance in the graph to the source
$$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


class Solution {
public:
 bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
 unordered_map<int, vector<int>> adjs;
 for (const auto &edge: edges) {
 adjs[edge[0]].push_back(edge[1]);
 adjs[edge[1]].push_back(edge[0]);
 }

 unordered_set<int> visited;
 queue<int> q;
 q.push(source);
 while (!q.empty()) {
 int node = q.front();
 q.pop();
 if (node == destination) return true;
 for (int next_node: adjs[node]) {
 if (visited.find(next_node) != visited.end())
 continue;
 q.push(next_node);
 visited.insert(next_node);
 }
 }
 return false;
 }
};

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

405. Convert a Number to Hexadecimal

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

Intuition

Just use the transformation algorithm from decimal to hexadecimal

Approach

Simulation by doing the following:

compute remain = num % 16, add remain to the result (push_back)
update num = (num - remainder) / 16
repeat step 1 and step 2 until num is 0

Notice that when num < 0, we need use its complement.

Complexity

Time complexity: the loop depends on the number of digits of num.
$$O(\log n)$$
Space complexity:
$$ O(1) $$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 string toHex(long num) {
 if (num == 0) return "0";
 if (num < 0) num = INT_MAX + num + 2 + INT_MAX;
 string result;
 while (num) {
 int divide = num % 16;
 num = (num - divide) / 16;
 if (divide < 10) result += ('0' + divide);
 else result += ('a' + (divide - 10));
 }
 reverse(result.begin(), result.end());
 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;
 }
};