将数组元素拆分为严格递增和递减的序列

在程序设计中，经常需要将一个数组拆分为严格递增和递减的序列。本文将介绍如何实现这个功能。

方案1：暴力枚举

最朴素的方法是暴力枚举。具体来说，我们从数组的开头开始，不断向后扫描。扫描到的每一个元素都要放到某一个序列中，这个序列要么是严格递增的，要么是严格递减的。如果当前元素可以放到递增序列中，则放到递增序列中；否则，放到递减序列中。这个过程要一直持续到数组的结尾。暴力枚举的时间复杂度是$O(n^2)$，空间复杂度是$O(n)$。

def split_array(nums):
    inc, dec = [], []
    for i in range(len(nums)):
        if not inc or inc[-1] < nums[i]:
            inc.append(nums[i])
        elif not dec or dec[-1] < nums[i]:
            dec.append(nums[i])
        else:
            return False
    return True

方案2：贪心算法

更加高效的方法是采用贪心算法。具体来说，我们从数组的开头开始，不断向后扫描。扫描到的每一个元素都要放到某一个序列中，这个序列要么是严格递增的，要么是严格递减的。如果当前元素可以放到递增序列中，则放到递增序列中并且更新递增序列的末尾元素；否则，放到递减序列中并且更新递减序列的末尾元素。这个过程要一直持续到数组的结尾。贪心算法的时间复杂度是$O(n)$，空间复杂度是$O(1)$。

def split_array(nums):
    inc_tail, dec_tail = float('-inf'), float('-inf')
    for i in range(len(nums)):
        if nums[i] <= inc_tail:
            if nums[i] <= dec_tail:
                return False
            else:
                dec_tail = nums[i]
        else:
            if nums[i] <= dec_tail:
                inc_tail = nums[i]
            else:
                inc_tail = dec_tail = nums[i]
    return True

方案3：动态规划

最优秀的方法是采用动态规划。具体来说，我们定义dp[i][j]表示将前i个元素分成j个严格递增或递减的序列时是否合法。如果dp[i][j]=True，则前i个元素可以被分成j个严格递增或递减的序列；如果dp[i][j]=False，则前i个元素无法被分成j个严格递增或递减的序列。状态转移方程为：

$$ dp[i][j] = \bigvee_{k=0}^{i-1} [dp[k][j-1] \land s[k+1 \cdots i] \text{ is strictly increasing or decreasing}] $$

其中，$\vee$表示逻辑或，$\land$表示逻辑与，$s[k+1 \cdots i]$表示从位置k+1到位置i的子数组。动态规划的时间复杂度是$O(n^2k)$，空间复杂度是$O(nk)$。

def split_array(nums):
    n = len(nums)
    dp = [[False] * (n+1) for _ in range(n+1)]
    for i in range(1, n+1):
        dp[i][1] = True
        for j in range(2, i+1):
            for k in range(j-1, i):
                if dp[k][j-1] and (nums[k] < nums[i-1] or nums[k] > nums[i-1]):
                    dp[i][j] = True
                    break
    for j in range(1, n+1):
        if dp[n][j]:
            return True
    return False