# ❤ 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!

## 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]  and dp [i]  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 =  * N   # The length of the longest turbulent sub array ending at position I and arr [I - 1] < arr [i]
down =  * 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;
}
}
``` More links to my wonderful articles are welcome

Summary of various computer / software / life / music / animation / film skills (you can certainly find the skills you need)

Brush the questions with the force deduction algorithm, sort out the notes according to the mind map, and quickly remember the key contents of the algorithm (welcome to punch in and brush the questions with the blogger)

Sorting out of thinking map of computer professional knowledge

Sorting out the mind map of all Python knowledge points most worthy of collection, with common codes / methods / libraries / data structures / common errors / classic ideas (under continuous update)

The most valuable collection of C + + all knowledge points, mind map sorting (Zheng Li edition of Tsinghua University), 906 subjects of software engineering preliminary test of Southeast University

The most valuable collection of all knowledge points of computer network, mind map sorting (Royal postgraduate entrance examination), with classic 5-layer structure in Chinese and English and framework introduction

The most collectable algorithm analysis and design, sorting out all knowledge points and mind mapping (mu course of Peking University)

The most collectable data structure is the sorting of all knowledge points and thinking maps (royal way postgraduate entrance examination), with the sorting of classic questions

The most collectable introduction to artificial intelligence: sorting out the mind map of all knowledge points (Wang Wanliang Mu course)

Sorting out of all knowledge points of numerical analysis most worthy of collection (mu course of Northeast University)

The most valuable collection of all knowledge points of digital image processing and mind mapping (mu course of Wuhan University)

A map of red black tree solves the problem of inserting and deleting all red black trees, including the comparison of detailed operation principles

Whether the time / space complexity of various common sorting algorithms is stable, the selection of algorithms, and the improvement of mind mapping

Sorting out the thinking map of knowledge points of postgraduate entrance examination related subjects

Postgraduate entrance examination experience - Software Engineering, School of software, Southeast University (you should know all kinds of pits and review skills of these basic and professional courses)

906 data structure of software engineering of Southeast University C + + sorting of real topic thinking map over the years

Sorting out the thinking map of real problems over the years in three subjects of software engineering retest of Southeast University

The most collectable thought map of all knowledge points of advanced mathematics for postgraduate entrance examination (Zhang Yu, Tang Jiafeng), with problem solving skills / error prone points / knowledge points

The most collectable arrangement of all knowledge points of linear algebra for postgraduate entrance examination (Zhang Yu, Tang Jiafeng), with habitual thinking / problem-solving skills / arrangement of error prone points

The mean value theorem of higher mathematics is a thought map to solve all the problems of the mean value theorem

The knowledge points and skills of thinking and repairing in postgraduate entrance examination are more important in the same kind of meeting. Sorting out the thinking map of 1800 error prone questions in the same kind of meeting

Knowledge points and skills of modern history in postgraduate entrance examination

The original knowledge points and skills of MA in the postgraduate entrance examination

Sorting of thinking map of Python related technical knowledge points

All notes on Java related technologies / ssm framework

Technology related Xiaomi mobile phone

Release time and price of Xiaomi Hongmi mobile phone models

Various series division and characteristics of common mobile phone brands

The performance of CPU s and GPU s of past dynasties and the meaning of common suffixes

Posted on Sat, 02 Oct 2021 21:33:56 -0400 by jamal dakak