❤ Mind mapping sorting high frequency array 16: dynamic programming construction and sliding window solution of the longest turbulence sub array, force deduction 978 ❤ ️

This column is a summary and induction of various methods for the problem of force deduction algorithm, sorting out the most important ideas and knowledge points and presenting them in the form of mind map. Of course, my detailed explanation of the map will also be added

The purpose is to memorize and recall the key points of the algorithm more conveniently and quickly (you don't have to look at the problem solution every time). After all, the algorithm can't be completely remembered after doing it once. Therefore, this paper is suitable for friends who already know the ideas and methods of problem solving and want to further strengthen understanding and memory, not for friends who contact this problem for the first time (you can go to the power button to see the official solution according to the question number, and then read the content of this article.)

For the directory links of all topics in this column, the order / precautions / skills of brushing algorithm topics, and the source files of mind map, please click This link.

If you want to enter a large factory, the brushing algorithm is essential. You are welcome to punch in the brushing force deduction algorithm together with the blogger. The blogger has synchronously updated the video explanation of the algorithm and the explanation of other articles / maps, which is easier to understand, Welcome to see!

Title Link: https://leetcode-cn.com/problems/longest-turbulent-subarray/solution/si-wei-dao-tu-zheng-li-dong-tai-gui-hua-bswtn/

0. Map arrangement

1. Construction of dynamic programming

After training in the previous topics: Maximum suborder sum, Maximum subsequence product , for this problem of finding the longest array, we can easily think of using dynamic programming to solve it

However, it will be found that the design of dp array in this problem is not as easy as the previous two questions. The most difficult point is that the formation conditions of turbulence sub array are exactly two opposite states, and it is obviously unrealistic for us to use a dp array to represent these two states at the same time. Therefore, we must use two dp arrays to represent different states respectively in this problem Break and push on

The definition and recurrence formula of the two dp arrays are as follows:

When defining the name of dp array, we should try to directly reflect the meaning of dp array up [i] and down [i], so that it can be clear at a glance when writing code. Don't think about the meaning of dp [i] [0] and dp [i] [1] like the official definition

As for the recurrence formula, because the increase and decrease of turbulence subarray are alternating, the dp array of the previous state in the current state must be opposite. The specific dynamic demonstration process can be explained in the corresponding video

Secondly, we need to pay attention to the set one operation in the recursive formula, as shown in the figure below: we see that the fourth number 10 in the array rises from 2 to 10 in front of it, so we use down[i-1] to update the value of up[i], but for down[i], only number 10 meets the requirements, and the previous numbers do not meet the requirements, so its value is 1

It is not too difficult to write the code, but the set one operation mentioned above is very important in space optimization. Without space optimization, the dp array is stored with an array, and the initial value is 1. In fact, whether there is a set one operation in the code has no impact on the final result. However, after space optimization, the dp array only It is stored with a variable whose value changes continuously. If there is no timely set one operation, the final result must be wrong

2. Various conditions of sliding window

This problem can also be solved with the idea of sliding window. The most difficult point of sliding window is to determine the sliding conditions at both ends of the window

The two conditions for the right pointer to slide are well understood, that is, two conditions that meet the requirements. Of course, the conditions for the left pointer to slide are not met, but here is a note: the left pointer does not slide unit by unit, but directly jumps to the position of the right pointer. Because when left < right, [left,right+1] cannot form a "turbulent subarray" , all the numbers in the middle must be unsatisfied, so there is no need to slide one by one

Another difficulty of sliding window is the processing of boundary. For this problem, the window length becomes 1 (i.e. when left and right are equal): at this time, as long as arr[right] ≠ arr[right+1] , right can be shifted to the right by one unit; otherwise, both left and right should be shifted to the right at the same time, skipping the case where the two numbers are equal. The boundary conditions must be considered carefully, otherwise it is easy to make mistakes

Source code

Python:

# 1. Dynamic planning
# No space optimization
class Solution(object):
    def maxTurbulenceSize(self, arr: List[int]):
        N = len(arr)
        up = [1] * N   # The length of the longest turbulent sub array ending at position I and arr [I - 1] < arr [i]
        down = [1] * N # The length of the longest turbulent sub array ending at position I and arr [I - 1] > arr [i]
        res = 1
        for i in range(1, N):
            if arr[i - 1] < arr[i]:  # The growth and decrease of turbulent subarray are alternating
                up[i] = down[i - 1] + 1
                down[i] = 1
            elif arr[i - 1] > arr[i]:
                up[i] = 1
                down[i] = up[i - 1] + 1
            else:
                up[i] = 1
                down[i] = 1
            res = max(res, up[i], down[i])
        return res

# Spatial optimization
class Solution:
    def maxTurbulenceSize(self, arr: List[int]) -> int:
        down, up = 1, 1 # The length of the longest continuous subarray that ends with this element and is Valley / peak
        res = 1
        for i in range(1, len(arr)):
            if arr[i-1] > arr[i]:
                down = up + 1
                up = 1
            elif arr[i-1] < arr[i]:
                up = down + 1
                down = 1
            else:
                down, up = 1, 1
            res = max(res, down, up)
        return res
        
# 2. Sliding window
class Solution(object):
    def maxTurbulenceSize(self, arr: List[int]):
        n = len(arr)
        ret = 1
        left = right = 0

        while right < n - 1 :
            if left == right : # Special case: window length is 1
                if arr[left] == arr[left + 1] : # When the two pointers are equal, the left and right pointers move at the same time
                    left+=1
                
                right+=1 # When the two pointers are not equal, only the right pointer is moved
            else :  # Normal condition: the window length is not 1
                # In the following two cases, you can move the right pointer to expand the window
                if arr[right - 1] < arr[right] and arr[right] > arr[right + 1] :
                    right+=1
                elif arr[right - 1] > arr[right] and arr[right] < arr[right + 1] :
                    right+=1
                else : # If it is not satisfied, [left,right+1] cannot form a turbulence subarray. Move left to right directly
                    left = right               
            
            ret = max(ret, right - left + 1)
        return ret

java:

// 1. Dynamic planning
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int res = 1, up = 1, down = 1;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] < arr[i]) {
                up = down + 1;
                down = 1;
            } else if (arr[i - 1] > arr[i]) {
                down = up + 1;
                up = 1;
            } else {
                up = 1;
                down = 1;
            }
            res = Math.max(res, Math.max(up, down));
        }
        return res;
    }
}

// 2. Sliding window
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int n = arr.length;
        int ret = 1;
        int left = 0, right = 0;


        while (right < n - 1) {
            if (left == right) { // Special case: window length is 1
                if (arr[left] == arr[left + 1]) { // When the two pointers are equal, the left and right pointers move at the same time
                    left++;
                }
                right++; // When the two pointers are not equal, only the right pointer is moved
            } else {  // Normal condition: the window length is not 1
                // In the following two cases, you can move the right pointer to expand the window
                if (arr[right - 1] < arr[right] && arr[right] > arr[right + 1]) {
                    right++;
                } else if (arr[right - 1] > arr[right] && arr[right] < arr[right + 1]) {
                    right++;
                } else { // If it is not satisfied, [left,right+1] cannot form a turbulence subarray. Move left to right directly
                    left = right;
                }
            }
            ret = Math.max(ret, right - left + 1);
        }
        return ret;
    }
}