DP 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

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

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