问题描述
Given an array of numbers, find the longest alternating subsequence. That is, a subsequence [a1, a2, a3, ..., ak] where a1>a2, a2< a3,a3>a4 ..., or vice versa (graphically looks like / \ / \ / ... or \ / \ / \ /...) .
给出一个数组，找到最长的交替子序列，即其元素的大小关系不断交替。子序列不用连续。在英文中，一般subarray是连续的子序列，subsequence是可以不必连续的子序列。参考Geeksforgeeks的定义：
- A subbarray is a contiguous part of array.
- A subsequence is a sequence that can be derived from another sequence by zero or more elements, without changing the order of the remaining elements.
例如[1,2,3,4]，[1,2,3]是subarray也是subsequence，但是[1,3]只是subsequence。
询问补充
无
思路阐述
暴力破解
暴力破解方法就是找出所有子序列，然后从长到短找到符合要求的。因为生成所有子序列的时间复杂度是O(n*2n)，然后判断也需要O(n)，总共就是O((n2)*2^n)。
如何改进
暴力破解方法明显效率太低，一个原因就是对于已经违反规律的开头还会继续生成子序列。
因此我们可以在生成子序列的过程中加入检查，或者是针对规律来生成子序列。
DFS解法
对两个规律可以分别求最大子序列然后再取最大值。
对于一个规律，可以采用DFS，从左往右，每次取符合规律的数，之后递归剩下的部分。
因为两个规律其实很相似，可以用一个参数来控制是取大于还是小于上一个数，这样可以共用一个递归函数。
由于要的是最大长度，整个递归时间复杂度仍然非常高：假设给出的序列就是符合要求的序列，每次递归都得把剩下的所有元素递归一遍。可以稍微改进一下，就是记录找到的最长的序列，假如某个递归分支已经不能比之更长的时候，就放弃该分支。
DP解法
两个规律有明显的关系，可以考虑使用DP。
假设有两个DP数组，fall[i]和rise[i]，代表以数组A的A[i]结尾的最大fall或者rise序列长度，那么自然可以得到递推公式：对于fall[i+1]，就找到A数组A[i+1]之前比A[i+1]大的元素k，使得rise[k+1]最大；rise同理。这样复杂度是O（n^2）。
代码
import copy
class Solution:
# recursion solution
def getLongestAlternatingSubsequence(self, A):
if not A:
return 0
if len(A) == 1:
return 1
self.ret = 0
self.seq = []
self.recur(A[1:], True, 1, [A[0]])
self.recur(A[1:], False, 1, [A[0]])
return self.seq
def recur(self, A, f, curL, curSeq):
if curL > self.ret:
self.seq = copy.deepcopy(curSeq)
self.ret = max(self.ret, curL)
if not A:
return
if curL + len(A) <= self.ret:
return
for i in range(len(A)):
if f:
# f: find rise
if A[i] > curSeq[-1]:
curSeq.append(A[i])
self.recur(A[i + 1:], False, curL + 1, list(curSeq))
curSeq.pop()
else:
if A[i] < curSeq[-1]:
curSeq.append(A[i])
self.recur(A[i + 1:], True, curL + 1, list(curSeq))
curSeq.pop()
# DP solution
def getLongestAlternatingSubsequenceDP(self, A):
if not A:
return 0
if len(A) == 1:
return 1
dpRiseEnd = [0] * len(A)
dpFallEnd = [0] * len(A)
backTrackRise = [[A[0]] for _ in range(len(A))]
backTrackFall = [[A[0]] for _ in range(len(A))]
dpFallEnd[0] = dpRiseEnd[0] = 1
for i in range(1, len(A)):
for j in range(i):
if A[j] < A[i]:
if dpFallEnd[j] + 1 > dpRiseEnd[i]:
backTrackFall[j].append(A[i])
backTrackRise[i] = copy.deepcopy(backTrackFall[j])
backTrackFall[j].pop()
dpRiseEnd[i] = max(dpRiseEnd[i], dpFallEnd[j] + 1)
if A[j] > A[i]:
if dpRiseEnd[j] + 1 > dpFallEnd[i]:
backTrackRise[j].append(A[i])
backTrackFall[i] = copy.deepcopy(backTrackRise[j])
backTrackRise[j].pop()
dpFallEnd[i] = max(dpFallEnd[i], dpRiseEnd[j] + 1)
return backTrackRise[-1] if len(backTrackRise[-1]) >= len(backTrackFall[-1]) else backTrackFall[-1]
个人更推荐DP解法。由于要求得到序列，所以需要存储节点，否则DP代码会更加简单。DP的时间和空间复杂度都是O(n^2)。因为后面的DP值依赖前面所有的DP值，因此不能使用滚动DP来节约空间。
可以看到我默认以A[0]为开始。这是因为，对于后面的最长交替序列，无论是以/开始还是以\开始，无论A[0]和A[1]A[2]的大小关系如何，都不影响最终结果，稍微画个图就知道了，把A[0]看做一个点'.'：
- 假设.在/下方或者中央，那么.可以代替A[1]；
- 假设.在/上方，那么可以加入组成更长的交替序列。
也就是说，一个序列的最大交替序列总是大于或者等于其子序列的交替子序列。所以，可以默认以A[0]为开头。
总结
DP-backTrack问题。难度hard。