Ziqi Han

LeetCode Day 60 Monotonic Stack (3/3)

2023-09-25T00:00:00-07:00

Today is the last day of training, I am feeling accomplished!

Question 1

Given an array of integers heights representing the histogram’s bar height where the width of each bar is 1, return the area of the largest rectangle in the histogram.

To solve this problem using the monotonic stack idea, the problem is to find the first column to the left and right of each column that is smaller than that column, so the order from the head of the stack (where the elements are popped off the head) to the bottom of the stack should be in order from largest to smallest. The top of the stack and the next element from the top of the stack, as well as the three elements to go on the stack make up the height and width of the maximum area we require.

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        heights.insert(0, 0)
        heights.append(0)
        stack = [0]
        result = 0
        for i in range(1, len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                mid_height = heights[stack[-1]]
                stack.pop()
                if stack:
                    # area = width * height
                    area = (i - stack[-1] - 1) * mid_height
                    result = max(area, result)
            stack.append(i)
        return result

LeetCode Day 59 Monotonic Stack (2/3)

2023-09-24T00:00:00-07:00

Continue the monotonic stack exercise!

Question 1

503. Next Greater Element II

Given a circular integer array nums (i.e., the next element of nums[nums.length - 1] is nums[0]), return the next greater number for every element in nums.

The next greater number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn’t exist, return -1 for this number.

This question is similar to LC739, but it’s going to use circular arrays.

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        dp = [-1] * len(nums)
        stack = []
        for i in range(len(nums)*2):
            while(len(stack) != 0 and nums[i%len(nums)] > nums[stack[-1]]):
                    dp[stack[-1]] = nums[i%len(nums)]
                    stack.pop()
            stack.append(i%len(nums))
        return dp

Question 2

42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

This is a common question in interviews, so it would be good to list all the approaches.

Double pointer method
Monotonic stack

The two-pointer method

The simplest Brute Force is also based on the double pointer to do: record the highest height of the left column and the highest height of the right column, you can calculate the current location of the rain area, which is calculated by the column. The current column rain area: min(the highest height of the left column, record the highest height of the right column) - the current column height.

In order to get the highest height on both sides, a double pointer is used to traverse the columns, traversing to both sides at every column. This causes double counting and is optimised:

We record the highest height on the left at each position on an array (maxLeft) and the highest height on the right on an array (maxRight), which avoids double counting.

The current position, the highest height on the left is the maximum of the highest height on the left of the previous position and this height.

That is, traverse from left to right: maxLeft[i] = max(height[i], maxLeft[i - 1]);

Iterate from right to left: maxRight[i] = max(height[i], maxRight[i + 1]);

class Solution:
    def trap(self, height: List[int]) -> int:
        leftheight, rightheight = [0]*len(height), [0]*len(height)
 
        leftheight[0]=height[0]
        for i in range(1,len(height)):
            leftheight[i]=max(leftheight[i-1],height[i])
        rightheight[-1]=height[-1]
        for i in range(len(height)-2,-1,-1):
            rightheight[i]=max(rightheight[i+1],height[i])
 
        result = 0
        for i in range(0,len(height)):
            summ = min(leftheight[i],rightheight[i])-height[i]
            result += summ
        return result

Monotonous stacks

2.1 Ideas:

2.1.1 Firstly, the monotonic stack calculates rain in the direction of the rows. 2.1.2 Using the order of elements in the monotonic stack The order from the head of the stack (elements are popped from the head of the stack) to the bottom of the stack should be from smallest to largest. This is because once you realise that the height of the added column is greater than the height of the stack head element, the notch will appear, the stack head element will be the column at the bottom of the notch, the second element from the stack head will be the column to the left of the notch, and the added element will be the column to the right of the notch. 2.1.3 What to do if you encounter a column of the same height. When we encounter the same element, we update the stack subscript, that is, we pop out the stack element (the old subscript) and add the new element (the new subscript) to the stack. This is because when we ask for the width, if we encounter a column of the same height, we need to use the rightmost column to calculate the width. 2.1.4 What values to keep in the stack Using a monotonic stack, the rain area is also calculated from the length * width. The length is calculated from the height of the columns and the width is calculated from the subscripts between the columns. So is it necessary to store an element of type pair<int, int> in the stack to save the height and subscripts of the columns? In fact, we don’t need to store the subscripts in the stack, if we want to know the corresponding height, we can use height[stack.top()] to know the corresponding height of the subscripts that are popped up.

2.2 Monotonic stack processing logic

The following logic is mainly three cases:

Case 1: the height of the currently traversed element (column) is less than the height of the top element of the stack height[i] < height[stack.top()]
Case 2: the height of the currently traversed element (column) is equal to the height of the top element height[i] == height[st.top()].
Case 3: the height of the currently traversed element (column) is greater than the height of the top element of the stack height[i] > height[st.top()]

First add the column with subscript 0 to the stack, st.push(0);. The stack holds the elements we’ve traversed, so add subscript 0 first. Then start traversing all the columns from subscript 1, for (int i = 1; i < height.size(); i++).

If the height of the currently traversed element (column) is less than the height of the top element of the stack, add that element to the stack, since the stack is meant to be kept in smallest-to-largest order (from the head of the stack to the bottom of the stack).

If the height of the currently traversed element (column) is equal to the height of the top element, update the top element, because if you encounter a column of the same height, you need to use the rightmost column to calculate the width.

If the current traversal of the element (column) height is greater than the height of the top stack element, at this time there is a notch

Take the top element of the stack and pop out the top element of the stack, which is the bottom of the notch, i.e., the middle position, with the subscript mid and the corresponding height as height[mid].

The top element of the stack at this point, st.top(), is the left position of the notch, subscripted st.top(), with a corresponding height of height[st.top()].

The currently traversed element, i, is the position to the right of the notch, subscripted by i, with the corresponding height being height[i].

At this point it can be found that it is actually the top of the stack and the next element on the top of the stack and the element to be added to the stack, three elements to catch the water!

Then the height of the rain is min(height of the left side of the groove, height of the right side of the groove) - height of the bottom of the groove, the code is: int h = min(height[st.top()], height[i]) - height[mid];

The width of the rain is the subscript of the right side of the notch - the subscript of the left side of the notch - 1 (because only the width of the middle is sought), the code is: int w = i - st.top() - 1 ;

The volume of the current notch rain is: h * w.

class Solution:
    def trap(self, height: List[int]) -> int:
        stack = [0]
        result = 0
        for i in range(1, len(height)):
            while stack and height[i] > height[stack[-1]]:
                mid_height = stack.pop()
                if stack:
                    h = min(height[stack[-1]], height[i]) - height[mid_height]
                    w = i - stack[-1] - 1
                    result += h * w
            stack.append(i)
        return result

LeetCode Day 58 Monotonic Stack (1/3)

2023-09-23T00:00:00-07:00

Dynamic programming is finished, coming to the last piece of content: the monotonic stack, which is just three days of content in total.

1. Fundamental knowledges of monotonic stack

1.1 When to use monotonic stack?

Usually a one-dimensional array, to find the location of the first element to the right or left of any element larger or smaller than itself, at this point we have to think that we can use a monotonic stack. The time complexity is O(n).

The essence of the monotonic stack is space for time, because in the process of traversal of the need to use a stack to record the first right than the current element of the element, the advantage is that the entire array only needs to be traversed once.

More bluntly, is to use a stack to record the elements we have traversed, because we traverse the array, we do not know what elements have been traversed before, so traversing an element can not be found is not traversed before a smaller, so we need to use a container (here with a monotonic stack) to record our traversal of the elements.

1.2 Three main judgement conditions for using a monotonic stack.

The case where the currently traversed element T[i] is less than the top stack element T[st.top()].
The case where the currently traversed element T[i] is equal to the top element T[st.top()].
The case where the currently traversed element T[i] is greater than the top of the stack element T[st.top()].

2. Question 1

739. Daily Temperatures

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

The Brute Force is still the first thing that comes to mind, a two level for loop that scours out the number of days to wait at least. The time complexity is O(n^2).

This is a question that applies a monotonic stack and is analysed to cover the following three cases:

Case 1: The current traversed element T[i] is less than the top element T[st.top()] of the stack
Case 2: The case where the currently traversed element T[i] is equal to the top stack element T[st.top()].
Case 3: the current traversal of the element T[i] is greater than the top of the stack element T[st.top()].

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        answer = [0]*len(temperatures)
        stack = [0]
        for i in range(1,len(temperatures)):
 
            if temperatures[i]<=temperatures[stack[-1]]:
                stack.append(i)
 
            else:
                while len(stack) != 0 and temperatures[i]>temperatures[stack[-1]]:
                    answer[stack[-1]]=i-stack[-1]
                    stack.pop()
                stack.append(i)
 
        return answer

3. Question 2

496. Next Greater Element I

The next greater element of some element x in an array is the first greater element that is to the right of x in the same array.

You are given two distinct 0-indexed integer arrays nums1 and nums2, where nums1 is a subset of nums2.

For each 0 <= i < nums1.length, find the index j such that nums1[i] == nums2[j] and determine the next greater element of nums2[j] in nums2. If there is no next greater element, then the answer for this query is -1.

Return an array ans of length nums1.length such that ans[i] is the next greater element as described above.

To analyse the following three cases.

Case 1: the current traversal of the element T[i] is less than the top of the stack element T[st.top()] case
- At this time to meet the incremental stack (the order of the stack head to the bottom of the stack), so directly into the stack.
Case 2: the current traversal of the element T[i] is equal to the top of the stack element T[st.top()] case
- If equal, still directly into the stack, because we require the first element on the right than their own, rather than greater than or equal to!
Case 3: the current traversal of the element T[i] is greater than the top of the stack element T[st.top()] case
- At this point if the stack into the stack will not satisfy the incremental stack, this is also to find the right side of the first element larger than their own time.

Determine whether the top element of the stack has appeared in nums1, (note that the elements in the stack are elements of nums2), if it has appeared, start recording results.

Record the results of this piece of logic there is a little bit around, to be clear, at this time, the top of the stack element in the nums2 array on the right side of the first larger element is nums2[i] (that is, the current traversal of the element).

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = [-1]*len(nums1)
        stack = [0]
        for i in range(1,len(nums2)):
            if nums2[i]<=nums2[stack[-1]]:
                stack.append(i)
            else:
                while len(stack)!=0 and nums2[i]>nums2[stack[-1]]:
                    if nums2[stack[-1]] in nums1:
                        index = nums1.index(nums2[stack[-1]])
                        result[index]=nums2[i]
                    stack.pop()                 
                stack.append(i)
        return result

LeetCode Day 57 Dynamic Programming (17/17)

2023-09-22T00:00:00-07:00

Today is the last day of the Dynamic Programming exercise!

Question 1

647. Palindromic Substrings

Given a string s, return the number of palindromic substrings in it.

A string is a palindrome when it reads the same backward as forward.

A substring is a contiguous sequence of characters within the string.

It can be solved with Brute force, but it requires two layers of for loops to traverse the interval start position and end position, and then one more layer of traversal to determine if the interval is a palindrome. So the time complexity is O(n^3).

So we also have to use dynamic programming. When determining the recursive formula, the following cases have to be analysed.

Overall there are two kinds, that is, s[i] and s[j] are equal and s[i] and s[j] are not equal these two kinds.

When s[i] is not equal to s[j], there’s nothing more to say, dp[i][j] must be false.

When s[i] is equal to s[j], this is a bit more complicated, with the following three cases

Case 1: subscripts i and j are the same, the same character e.g. a, which is of course a palindrome substring
Case 2: the difference between subscript i and j is 1, such as aa, which is also a palindrome.
Case 3: subscript: i and j difference is greater than 1, such as cabac, at this time s[i] and s[j] has been the same, we look at the i to j interval is not a palindrome sub-string on the aba is not a palindrome on it, then aba’s interval is the interval of i +1 and j-1 interval, the interval is not a palindrome on the look at the dp[i + 1][j - 1] whether or not it is true.

class Solution:
    def countSubstrings(self, s: str) -> int:
        dp = [[False] * len(s) for _ in range(len(s))]
        result = 0
        for i in range(len(s)-1, -1, -1): 
            for j in range(i, len(s)):
                if s[i] == s[j] and (j - i <= 1 or dp[i+1][j-1]): 
                    result += 1
                    dp[i][j] = True
        return result

Question 2

516. Longest Palindromic Subsequence

Given a string s, find the longest palindromic subsequence’s length in s.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Still applying the five parts of dynamic programming:

Determine the dp array (dp table) and the meaning of the subscripts
1. dp[i][j]: the length of the longest echo subsequence of string s in the range [i, j] is dp[i][j].
Determining the recursive formula
1. In the topic of determining palindromic substrings, the key logic is to see if s[i] is the same as s[j]. If s[i] is the same as s[j], then dp[i][j] = dp[i + 1][j - 1] + 2;
2. If s[i] and s[j] are not the same, it means that the simultaneous addition of s[i] and s[j] can not increase the length of the echo subsequence in the interval [i,j], then add s[i] and s[j] separately to see which one can form the longest echo subsequence.
3. The length of the echo subsequence joining s[j] is dp[i + 1][j].
4. The length of the palindrome subsequence joining s[i] is dp[i][j - 1].
5. Then dp[i][j] must be taken as the maximum, i.e., dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
How the dp array is initialised
1. First of all, we need to consider the case when i and j are the same, from the recursive formula: dp[i][j] = dp[i + 1][j - 1] + 2; we can see that the recursive formula can not calculate the case when i and j are the same.
2. So we need to initialise it manually, when i and j are the same, then dp[i][j] must be equal to 1, i.e.: the length of the echo subsequence of a character is 1.
3. Other cases dp[i][j] initial 0 on the line, so that the recursive formula: dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); in dp[i][j] will not be covered by the initial value.
Determining the traversal order
1. From the recursive formula, we can see that dp[i][j] depends on dp[i + 1][j - 1], dp[i + 1][j] and dp[i][j - 1]. So traversing i must be done from bottom to top to ensure that the data in the next row is computed.
Example derivation of dp array

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        dp = [[0] * len(s) for _ in range(len(s))]
        for i in range(len(s)):
            dp[i][i] = 1
        for i in range(len(s)-1, -1, -1):
            for j in range(i+1, len(s)):
                if s[i] == s[j]:
                    dp[i][j] = dp[i+1][j-1] + 2
                else:
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
        return dp[0][-1]

LeetCode Day 56 Dynamic Programming (16/17)

2023-09-21T00:00:00-07:00

Dynamic planning is coming to an end, and I thought it was a lot of content for dynamic planning at the time, but it’s finish very quickly.

Question 1

583. Delete Operation for Two Strings

Given two strings word1 and word2, return the minimum number of steps required to make word1 and word2 the same.

In one step, you can delete exactly one character in either string.

This question compared to LC 115, in fact, is that both strings can be deleted, the situation is a little more complex, but the overall idea is the same

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0] * (len(word2)+1) for _ in range(len(word1)+1)]
        for i in range(len(word1)+1):
            dp[i][0] = i
        for j in range(len(word2)+1):
            dp[0][j] = j
        for i in range(1, len(word1)+1):
            for j in range(1, len(word2)+1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j-1] + 2, dp[i-1][j] + 1, dp[i][j-1] + 1)
        return dp[-1][-1]

Question 2

72. Edit Distance

Given two strings word1 and word2, return the minimum number of operations required to convert word1 to word2.

You have the following three operations permitted on a word:

Insert a character

Delete a character

Replace a character

Edit Distance is a classic problem solved with a dynamic gauge, this problem may look like it’s complicated, but the minimum edit distance can be cleverly calculated using a dynamic gauge. Use the five parts of dynamic programming to do an analysis:

Determine the dp array (dp table) and what the subscripts mean

dp[i][j] denotes the string word1 ending with subscript i-1, and the string word2 ending with subscript j-1, with the nearest edit distance dp[i][j].

Determine the recursive formula

Overall, there are several operations as follows:

if (word1[i - 1] == word2[j - 1])
    No operation
if (word1[i - 1] != word2[j - 1])
    Insert
    Delete
    Replace

2.1 if (word1[i - 1] == word2[j - 1]) then it means that without any editing, dp[i][j] should be dp[i - 1][j - 1], i.e., dp[i][j] = dp[i - 1][j - 1]; 2.2 if (word1[i - 1] ! = word2[j - 1]), then you need to edit, how to edit it?

2.2.1 Operation 1: word1 delete an element, then it is the following label i - 2 for the end of the word1 and j-1 for the end of the word2 of the nearest editing distance plus an operation. i.e. dp[i][j] = dp[i - 1][j] + 1; 2.2.2 Operation 2: word2 delete an element, then is the subscript i - 1 for the end of the word1 and j-2 for the end of the word2 of the nearest edit distance plus an operation. That is dp[i][j] = dp[i][j - 1] + 1; 2.2.3 Operation 3: Replace the element, word1 replace word1[i - 1] to make it the same as word2[j - 1], at this time do not have to add or delete elements.

how to initialise dp array

dp[i][j] denotes the string word1 ending with subscript i-1, and the string word2 ending with subscript j-1, with the nearest edit distance dp[i][j].

So what do dp[i][0] and dp[0][j] represent?

dp[i][0] : The string word1 ending with subscript i-1, and the empty string word2, with the nearest edit distance of dp[i][0].

Then dp[i][0] should be i, all the elements in word1 do delete operation, that is: dp[i][0] = i;

Similarly, dp[0][j] = j;

determine the traversal order

from the following four recursive formulas:

dp[i][j] = dp[i - 1][j - 1] dp[i][j] = dp[i - 1][j - 1] + 1 dp[i][j] = dp[i][j - 1] + 1 dp[i][j] = dp[i - 1][j] + 1 It can be seen that dp[i][j] is dependent on the left, top and upper left elements.

Derive the dp array by example

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0] * (len(word2)+1) for _ in range(len(word1)+1)]
        for i in range(len(word1)+1):
            dp[i][0] = i
        for j in range(len(word2)+1):
            dp[0][j] = j
        for i in range(1, len(word1)+1):
            for j in range(1, len(word2)+1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
        return dp[-1][-1]

LeetCode Day 55 (Day 54 is rest day) Dynamic Programming (15/17)

2023-09-20T00:00:00-07:00

Continuing to practice with subsequences questions with dp!

Question 1

392. Is Subsequence

Given two strings s and t, return true if s is a subsequence of t, or false otherwise.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).

The first thing that comes to mind is the double pointer solution, which has a complexity of O(n) and is acceptable. However, since we are practising dynamic programming, it is better to solve it along the lines of dynamic programming.

When determining the recursive formula, first consider the following two operations, organised as follows:

if (s[i - 1] == t[j - 1])
- A character found in t also appears in s
if (s[i - 1] ! = t[j - 1])
- Equivalent to t to remove the element and continue matching

if (s[i - 1] == t[j - 1]) then dp[i][j] = dp[i - 1][j - 1] + 1;, because an identical character is found, the length of the identical subsequence naturally has to be added to dp[i-1][j-1] by 1

if (s[i - 1] ! = t[j - 1]), this time is equivalent to t to delete elements, t if the current element t[j - 1] deleted, then the value of dp[i][j] is Look at s[i - 1] and t[j - 2] of the results of the comparison of that, that is: dp[i][j] = dp[i][j - 1];

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        dp = [[0] * (len(t)+1) for _ in range(len(s)+1)]
        for i in range(1, len(s)+1):
            for j in range(1, len(t)+1):
                if s[i-1] == t[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = dp[i][j-1]
        if dp[-1][-1] == len(s):
            return True
        return False

Question 2

115. Distinct Subsequences

You are given two integer arrays nums1 and nums2. We write the integers of nums1 and nums2 (in the order they are given) on two separate horizontal lines.

We may draw connecting lines: a straight line connecting two numbers nums1[i] and nums2[j] such that:

nums1[i] == nums2[j], and

the line we draw does not intersect any other connecting (non-horizontal) line.

Note that a connecting line cannot intersect even at the endpoints (i.e., each number can only belong to one connecting line).

Return the maximum number of connecting lines we can draw in this way.

This question can’t be done with double pointers, you have to use dynamic programming.

Recursive formula for: dp[i][j] = dp[i - 1][j].

From the recursive formula dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; and dp[i][j] = dp[i - 1][j]; you can see that dp[i][j] is derived from the top and the top-left, then dp[i][0] and dp[0][j] must be initialised.

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        n1, n2 = len(s), len(t)
        if n1 < n2:
            return 0
 
        dp = [0 for _ in range(n2 + 1)]
        dp[0] = 1
 
        for i in range(1, n1 + 1):
 
            prev = dp.copy()
            end = i if i < n2 else n2
            for j in range(1, end + 1):
                if s[i - 1] == t[j - 1]:
                    dp[j] = prev[j - 1] + prev[j]
                else:
                    dp[j] = prev[j]
        return dp[-1]

LeetCode Day 53 Dynamic Programming (14/17)

2023-09-19T00:00:00-07:00

Continuing to practice with subsequences questions with dp!

Question 1

1143. Longest Common Subsequence

Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

For example, "ace" is a subsequence of "abcde".

A common subsequence of two strings is a subsequence that is common to both strings.

The difference between this question and Dynamic Programming: LC 718 is that here it is not required to be continuous, but the rest of the ideas are the same

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
        for i in range(1, len(text1) + 1):
            for j in range(1, len(text2) + 1):
                if text1[i - 1] == text2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
 
        return dp[len(text1)][len(text2)]

Question 2

1035. Uncrossed Lines

You are given two integer arrays nums1 and nums2. We write the integers of nums1 and nums2 (in the order they are given) on two separate horizontal lines.

We may draw connecting lines: a straight line connecting two numbers nums1[i] and nums2[j] such that:

nums1[i] == nums2[j], and

the line we draw does not intersect any other connecting (non-horizontal) line.

Note that a connecting line cannot intersect even at the endpoints (i.e., each number can only belong to one connecting line).

Return the maximum number of connecting lines we can draw in this way.

Straight lines cannot intersect, which means that if you find a subsequence of string A that is the same as string B, and this subsequence does not change the relative order, as long as the relative order does not change, the lines linking the same numbers will not intersect.

The question says to find the maximum number of lines drawn, in fact, is to find the length of the longest common subsequence of the two strings!

class Solution:
    def maxUncrossedLines(self, A: List[int], B: List[int]) -> int:
        dp = [[0] * (len(B)+1) for _ in range(len(A)+1)]
        for i in range(1, len(A)+1):
            for j in range(1, len(B)+1):
                if A[i-1] == B[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        return dp[-1][-1]

LeetCode Day 52 Dynamic Programming (13/17)

2023-09-18T00:00:00-07:00

After practicing stock trading, I started practicing subsequence problems today.

Question 1

300. Longest Increasing Subsequence

Given an integer array nums, return the length of the longest strictly increasing

subsequence.(A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.)

With the help of dynamic programming in five parts:

Definition of dp[i]
1. It is important to correctly define the meaning of the dp array in this problem. dp[i] denotes the length of the longest incremental subsequence ending in nums[i] that includes i before i
The state transfer equation
1. The longest ascending subsequence at position i is equal to the maximum of the longest ascending subsequence + 1 at each position j from 0 to i-1. So: if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1); Note that instead of comparing dp[i] to dp[j] + 1, we’re taking the maximum value of dp[j] + 1 here.
Initialisation of dp[i]
1. For every i, the corresponding dp[i] (i.e., the longest increasing subsequence) starts with a size of at least 1.
Determining the traversal order dp[i] is derived from the longest increasing subsequence at each position from 0 to i-1, so traversing i must be done from front to back.
Example of derivation of dp array

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums)
        dp = [1] * len(nums)
        result = 1
        for i in range(1, len(nums)):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
            result = max(result, dp[i]) 
        return result

Question 2

674. Longest Continuous Increasing Subsequence

Given an unsorted array of integers nums, return the length of the longest continuous increasing subsequence (i.e. subarray). The subsequence must be strictly increasing.

A continuous increasing subsequence is defined by two indices l and r (l < r) such that it is [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] and for each l <= i < r, nums[i] < nums[i + 1].

If nums[i] > nums[i - 1], then the length of a continuously increasing subsequence ending in i must be equal to the length of a continuously increasing subsequence ending in i - 1 + 1 .

i.e.: dp[i] = dp[i - 1] + 1.

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        result = 1
        dp = [1] * len(nums)
        for i in range(len(nums)-1):
            if nums[i+1] > nums[i]: #连续记录
                dp[i+1] = dp[i] + 1
            result = max(result, dp[i+1])
        return result

LeetCode Day 51 Dynamic Programming (12/17)

2023-09-17T00:00:00-07:00

Last day of practice on stock trading problems!

Question 1

309. Best Time to Buy and Sell Stock with Cooldown

You are given an array prices where prices[i] is the price of a given stock on the ith day.

Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:

After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

Compared to LC122, this question adds a freeze period, so there are four states:

State 1: Holding stock state (buying the stock today, or buying the stock before and then not acting on it and holding it) Not holding the stock state, and here there are two sell stock states
State 2: Hold Sell Stock status (sold the stock two days ago to get through a one-day freeze. Or the day before is the sell stock status, has not been operated)
State 3: Sell the stock today
State 4: Frozen status today, but the frozen status is not sustainable and only lasts for one day!

So the code is as follows, the process of dp can correspond to these states.

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0:
            return 0
        dp = [[0] * 4 for _ in range(n)]  
        dp[0][0] = -prices[0]  
        for i in range(1, n):
            dp[i][0] = max(dp[i-1][0], max(dp[i-1][3], dp[i-1][1]) - prices[i])  
            dp[i][1] = max(dp[i-1][1], dp[i-1][3])  
            dp[i][2] = dp[i-1][0] + prices[i]  
            dp[i][3] = dp[i-1][2]  
        return max(dp[n-1][3], dp[n-1][1], dp[n-1][2]) 

Question 2

714. Best Time to Buy and Sell Stock with Transaction Fee

You are given an array prices where prices[i] is the price of a given stock on the ith day, and an integer fee representing a transaction fee.

Find the maximum profit you can achieve. You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.

Note:

You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

The transaction fee is only charged once for each stock purchase and sale.

Compared to LC122, this question just needs to subtract the commission when calculating the sell operation, the code is almost the same.

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp = [[0] * 2 for _ in range(n)]
        dp[0][0] = -prices[0] 
        for i in range(1, n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i] - fee)
        return max(dp[-1][0], dp[-1][1])

LeetCode Day 50 Dynamic Programming (11/17)

2023-09-16T00:00:00-07:00

Continuing with the stock trading exercise, but today it is more difficult and the LeetCode is labelled as Hard.

Question 1

123. Best Time to Buy and Sell Stock III

You are given an array prices where prices[i] is the price of a given stock on the ith day.

Find the maximum profit you can achieve. You may complete at most two transactions.

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

Although the number of times it takes to sell a stock has gone from one to two, it’s a lot harder than it was before. There is more variety in the options of choosing not to sell one day, or choosing to sell one or both.

When choosing the recursive formula to reach the dp[i][1] state, there are two specific operations:

Operation 1: the stock was bought on day i, then dp[i][1] = dp[i-1][0] - prices[i]
Operation 2: No operation is done on day i. Instead, it follows the state of buying on the previous day, i.e.: dp[i][1] = dp[i - 1][1]

So does dp[i][1] pick dp[i-1][0] - prices[i], or dp[i - 1][1]?

It must be the biggest one, so dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

Similarly dp[i][2] has two operations:

Operation 1: the stock is sold on day i, then dp[i][2] = dp[i - 1][1] + prices[i]
Operation 2: There is no operation on day i, and it follows the state of the stock sold on the previous day, i.e.: dp[i][2] = dp[i - 1][2]

So dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

The same reasoning can be introduced for the remaining state part:

dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [[0] * 5 for _ in range(len(prices))]
        dp[0][1] = -prices[0]
        dp[0][3] = -prices[0]
        for i in range(1, len(prices)):
            dp[i][0] = dp[i-1][0]
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
            dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
            dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])
            dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])
        return dp[-1][4]

Question 2

188. Best Time to Buy and Sell Stock IV

You are given an integer array prices where prices[i] is the price of a given stock on the ith day, and an integer k.

Find the maximum profit you can achieve. You may complete at most k transactions: i.e. you may buy at most k times and sell at most k times.

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

Compared to the previous question, the number of transactions is limited. In a two-dimensional recursive array, it can be found that

Except for 0, an even number is a sell and an odd number is a buy.

The requirement of the question is that there should be at most k transactions, so the range of j is just defined as 2 * k + 1.

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [[0] * (2*k+1) for _ in range(len(prices))]
        for j in range(1, 2*k, 2):
            dp[0][j] = -prices[0]
        for i in range(1, len(prices)):
            for j in range(0, 2*k-1, 2):
                dp[i][j+1] = max(dp[i-1][j+1], dp[i-1][j] - prices[i])
                dp[i][j+2] = max(dp[i-1][j+2], dp[i-1][j+1] + prices[i])
        return dp[-1][2*k]