Это является частью серии объяснений решения LeetCode ( index ). Если вам понравилось это решение или нашли его полезным, Пожалуйста, нравится Этот пост и/или upvote Мое решение по сообщению на форумах LeetCode Анкет
Проблема LeetCode #376 (средняя): Последующая последующая мощность
Описание:
( прыгнуть в : Идея решения Код : JavaScript | Python | Java | C ++
Учитывая целочисленное массив Nums
, вернуть длину самых длинных Последовательность покачивания Анкет
A Последовательность покачивания это последовательность, в которой различия между последовательными числами строго чередуются между положительным и отрицательным. Первое различие (если кто -то существует) может быть либо положительным, либо отрицательным. Последовательность с менее чем двумя элементами – это тривиально последовательность.
- Например,
[1, 7, 4, 9, 2, 5]
это Последовательность покачивания Потому что различия(6, -3, 5, -7, 3)
альтернативно положительные и отрицательные. - Напротив,
[1, 4, 7, 2, 5]
и[1, 7, 4, 5, 5]
не являются последовательностями, первыми, потому что его первые два различия положительны, а второе, потому что его последнее различие – нулевой.
A Последующая последовательность получается путем удаления некоторых элементов (в конечном итоге, также нулевого) из исходной последовательности, оставляя оставшиеся элементы в их первоначальном порядке.
Примеры:
Вход: | Nums = [1,7,4,9,2,5] |
Выход: | 6 |
Объяснение: | Вся последовательность представляет собой последовательность покачивания. |
Вход: | Nums = [1,17,5,10,13,15,10,5,16,8] |
Выход: | 7 |
Объяснение: | Есть несколько последствий, которые достигают этой длины. Одним из них является [1,17,10,13,10,16,8]. |
Вход: | Nums = [1,2,3,4,5,6,7,8,9] |
Выход: | 2 |
Ограничения:
1. длиной
0 [i]
Идея:
( Прыгните к : Описание задачи Код : JavaScript | Python | Java | C ++
Ключевая реализация здесь заключается в том, что любое число, которое лежит в середине участка одного и того же направления, является посторонним, потому что чем более экстремальные числа являются лучшим выбором, поскольку они позволяют с большей вероятностью, что последующее число будет направленным сдача.
Таким образом, простой ответ здесь состоит в том, чтобы подсчитать точки перегиба в нашем входном массиве ( n ), где изменяется направление. Есть несколько способов сделать это, но в этом решении мы можем сохранить направленный флаг ( up ), чтобы отслеживать текущее направление, а затем увеличить наш ответ ( ans ) и инвертировать вверх Когда изменение найдено.
Одна сложная вещь заключается в установке начального направления. Согласно инструкциям, первый номер может представлять любое направление, поэтому нам придется подождать, пока мы не увидим другой номер, чтобы установить наше направление. Мы можем проверить это с помощью простого В то время как петля перед главной петлей.
Как только мы закончим, мы можем вернуть ANS Анкет
Реализация:
Все, кроме JavaScript, потребует дополнительной проверки перед основным циклом, чтобы учесть массив ввода со всем одинаковым номером.
Код JavaScript:
( Прыгните к : Описание задачи Идея решения
var wiggleMaxLength = function(N) { let len = N.length, i = 1 while (N[i] === N[i-1]) i++ let up = N[i-1] > N[i], ans = 1 for (; i < len; i++) if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1])) up = !up, ans++ return ans };
Код Python:
( Прыгните к : Описание задачи Идея решения
class Solution: def wiggleMaxLength(self, N: List[int]) -> int: lenN, i = len(N), 1 while i < lenN and N[i] == N[i-1]: i += 1 if i == lenN: return 1 up, ans = N[i-1] > N[i], 1 while i < lenN: if (up and N[i] < N[i-1]) or (not up and N[i] > N[i-1]): up = not up ans += 1 i += 1 return ans
Код Java:
( Прыгните к : Описание задачи Идея решения
class Solution { public int wiggleMaxLength(int[] N) { int len = N.length, i = 1, ans = 1; while (i < len && N[i] == N[i-1]) i++; if (i == len) return 1; boolean up = N[i-1] > N[i]; for (; i < len; i++) if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1])) { up = !up; ans++; } return ans; } }
C ++ Код:
( Прыгните к : Описание задачи Идея решения
class Solution { public: int wiggleMaxLength(vector& N) { int len = N.size(), i = 1, ans = 1; while (i < len && N[i] == N[i-1]) i++; if (i == len) return 1; bool up = N[i-1] > N[i]; for (; i < len; i++) if ((up && N[i] < N[i-1]) || (!up && N[i] > N[i-1])) up = !up, ans++; return ans; } };
Оригинал: “https://dev.to/seanpgallivan/solution-wiggle-subsequence-3e65”