如何通過在兩個 arrays 之間交替來找到最長的交替遞增子序列

Question

給定兩個 arrays 數字，我如何通過在兩個 arrays 的元素之間交替來找到最長的遞增子序列？ 例如

A = [4, 1, 10, 5, 9]
B = [4, 5, 7, 14]
so the output must be [1,4,5,7,9,14]

它必須采用 a 的元素、b 的元素、a 的元素、b 的元素……的格式。

我試圖找到一個解決方案，但我想不出任何東西，我嘗試了 LIS 方法，但由於該代碼只需要一個數組，這對我來說沒有意義，對不起

（以防萬一，為了更清楚 = [ 1(A), 4(B), 5(A), 7(B), 9(A), 14(B)] 也請注意順序不能已更改）謝謝，如果我措辭不正確，請見諒

Answer 1

最簡單的方法就是這樣做：

# lias: Longest Increasing Alternating Subsequence
def lias(curr, next, seq):
    good, elem = False, None
    while not good:
        if not curr: return seq
        elem = min(curr); curr.remove(elem)
        good = False if elem in seq or elem < max(seq, default=0) else True
    seq.append(elem)
    return lias(next, curr, seq)


if __name__ == '__main__':
    A = [4, 1, 10, 5, 9]
    B = [4, 5, 7, 14]
    print(lias(A,B, []))
    

Answer 2

您可以定義一個遞歸解決方案，該解決方案基於前一個元素和它來自的列表的其余元素，一次構建一個元素的序列。 每個遞歸都可以交換參數順序，以便邏輯只需要關心其中一個列表。

這可以通過攜帶基於迄今為止發現的最長序列的長度目標來進一步優化。

例如：

def longAltSeq(A,B,prev=None,minLen=0):
    result = longAltSeq(B,A,min(B)-1) if prev is None else [] # inverted params
    for i,a in enumerate(A): # Start with an item from A
        if prev is not None and a<=prev: continue     # increasing from previous
        if 2*min(len(A)-i,len(B)+1)<minLen: break     # not enough items left
        seq = [a]+longAltSeq(B,A[i+1:],a,len(result)) # alternate A<->B
        if len(seq)>len(result): result = seq         # track longest
    return result

輸出：

A = [4, 1, 10, 5, 9]
B = [4, 5, 7, 14]
print(longAltSeq(A,B))
[1, 4, 5, 7, 9, 14]

解決方案從反轉參數開始，因此列表的初始順序無關緊要

Answer 3

這是 JavaScript 中的一個可行的解決方案。 您應該能夠在 Python 或您需要的任何語言中復制該邏輯。 干杯，歡迎來到社區！

var A = [4, 1, 10, 5, 9];
var B = [4, 5, 7, 14];

run(A,B);

function getSmallest(list, limit){
    var results = [];
    list.forEach(number => {
    if (number > limit)
        results.push(number);
    });
    results.sort(function(a, b) {
        return a - b;
    });
  return results[0];
}

function run(list_a,list_b){
    var result = [];
    var current_list = 1;
    var current_limit = Number.NEGATIVE_INFINITY;
    
    while (current_limit != undefined) {
        current_limit = getSmallest((current_list) ? list_a : list_b, current_limit);
        current_list = !current_list;
        result.push(current_limit);
    }

    result.pop();
    console.log(result);
}