Question

元素值先减小然后增加的序列称为V-序列。在有效的V序列中，增量臂中应至少有一个元素和至少一个元素。

例如，“5 3 1 9 17 23”是有效的V序列，其在减少臂中具有两个元素，即5和3，并且增加臂中的3个元素即9,17和23。但序列“6 4 2”或“8 10 15”中没有一个是V序列，因为“6 4 2”在增加部分中没有元素，而“8 10 15”在减少部分没有元素。

鉴于N个序列的序列找到其最长（不一定是连续的）子序列，即V序列？

是否可以在O（n）/ O（logn）/ O（n ^ 2）中执行此操作？

Answer 1

该解决方案与最长非递减子序列的解决方案非常相似。不同之处在于，现在对于每个元素，您需要存储两个值 - 从该元素开始的最长V序列的长度是什么，以及从此开始的最长减少子序列的长度是多少。请看一下typical non-decreasing subsequence解决方案的解决方案，我相信这应该是一个足够好的提示。我相信你可以达到的最佳复杂度是O（n * log（n）），但复杂度O（n ^ 2）的解决方案更容易实现。

希望这有帮助。

Answer 2

以下是基于izomorphius的Python实现，非常有用的提示。这建立在不断增加的子序列问题的this implementation之上。正如izomorphius所说，它的工作原理是跟踪“到目前为止发现的最佳V”，以及“迄今为止发现的最佳增长序列”。注意，一旦识别出V，扩展V与扩展递减序列没有什么不同。此外，还必须有一个规则，即从先前发现的增加的子序列中“生成”新的候选V.

from bisect import bisect_left

def Vsequence(seq):
    """Returns the longest (non-contiguous) subsequence of seq that
    first increases, then decreases (i.e. a "V sequence").

    """
    # head[j] = index in 'seq' of the final member of the best increasing
    # subsequence of length 'j + 1' yet found
    head = [0]
    # head_v[j] = index in 'seq' of the final member of the best
    # V-subsequence yet found
    head_v = []
    # predecessor[j] = linked list of indices of best increasing subsequence
    # ending at seq[j], in reverse order
    predecessor = [-1] * len(seq)
    # similarly, for the best V-subsequence
    predecessor_v = [-1] * len(seq)
    for i in xrange(1, len(seq)):

        ## First: extend existing V's via decreasing sequence algorithm.
        ## Note heads of candidate V's are stored in head_v and that
        ## seq[head_v[]] is a non-increasing sequence
        j = -1  ## "length of best new V formed by modification, -1"
        if len(head_v) > 0:
            j = bisect_left([-seq[head_v[idx]] for idx in xrange(len(head_v))], -seq[i])

            if j == len(head_v):
                head_v.append(i)
            if seq[i] > seq[head_v[j]]:
                head_v[j] = i

        ## Second: detect "new V's" if the next point is lower than the head of the
        ## current best increasing sequence.
        k = -1  ## "length of best new V formed by spawning, -1"
        if len(head) > 1 and seq[i] < seq[head[-1]]:
            k = len(head)

            extend_with(head_v, i, k + 1)

            for idx in range(k,-1,-1):
                if seq[head_v[idx]] > seq[i]: break
                head_v[idx] = i

        ## trace new predecessor path, if found
        if k > j:
            ## It's better to build from an increasing sequence
            predecessor_v[i] = head[-1]
            trace_idx = predecessor_v[i]
            while trace_idx > -1:
                predecessor_v[trace_idx] = predecessor[trace_idx]
                trace_idx=predecessor_v[trace_idx]
        elif j > 0:
            ## It's better to extend an existing V
            predecessor_v[i] = head_v[j - 1]

        ## Find j such that:  seq[head[j - 1]] < seq[i] <= seq[head[j]]
        ## seq[head[j]] is increasing, so use binary search.
        j = bisect_left([seq[head[idx]] for idx in xrange(len(head))], seq[i])

        if j == len(head):
            head.append(i)  ## no way to turn any increasing seq into a V!
        if seq[i] < seq[head[j]]:
            head[j] = i

        if j > 0: predecessor[i] = head[j - 1]

    ## trace subsequence back to output
    result = []
    trace_idx = head_v[-1]
    while (trace_idx >= 0):
        result.append(seq[trace_idx])
        trace_idx = predecessor_v[trace_idx]

    return result[::-1]

一些示例输出：

>>> l1
[26, 92, 36, 61, 91, 93, 98, 58, 75, 48, 8, 10, 58, 7, 95]
>>> Vsequence(l1)
[26, 36, 61, 91, 93, 98, 75, 48, 10, 7]
>>> 
>>> l2
[20, 66, 53, 4, 52, 30, 21, 67, 16, 48, 99, 90, 30, 85, 34, 60, 15, 30, 61, 4]
>>> Vsequence(l2)
[4, 16, 48, 99, 90, 85, 60, 30, 4]

增加减少序列

2 个答案: