時間でサイズ3のソートされたサブシーケンスを見つけるアルゴリズムはありますか？

Iは、証明または反証配列が与えられると、アルゴリズムが存在する整数を三の指数を見つけ、私は、Jおよびkのように、I < J < KとA [ I ] < A [ J ] < A [ kは】（または、そのようなトリプルがないことがわかります）線形時間で。$A$$i, j$$k$$i < j < k$$A[i] < A[j] < A[k]$

これは宿題の質問ではありません。「そのようなアルゴリズムを実装してみてください」とフレーム化されたプログラミングフォーラムでそれを見ました。さまざまな実験の後では不可能だと思います。私の直感はそう教えてくれますが、それは実際には何の役にも立ちません。

正式に証明したいと思います。どうやってやるの？理想的には、段階的にレイアウトされた証明を見たいと思います。そして、もしあなたがとても傾いているなら、このような簡単な質問を一般的に証明/反証する方法についての説明をご覧ください。それが役立つ場合、いくつかの例：

[1,5,2,0,3] → (1,2,3)
[5,6,1,2,3] → (1,2,3)
[1,5,2,3] → (1,2,3)
[5,6,1,2,7] → (1,2,7)
[5,6,1,2,7,8] → (1,2,7)
[1,2,999,3] → (1,2,999)
[999,1,2,3] → (1,2,3)
[11,12,8,9,5,6,3,4,1,2,3] → (1,2,3)
[1,5,2,0,-5,-2,-1] → (-5,-2,-1)

反復処理でき、i < j（つまり、現在のj）が存在するたびに、新しいトリプルを作成して配列にプッシュすると想定しました。トリプルの1つが完了するまで、各トリプルのステップ実行と比較を続けます。だから、のようなものです、！しかし、トリプル配列のトリプルの数は最悪の場合入力リストのサイズに対応するため、これは単なるO（n ）よりも複雑だと思います。$A$$i < j$$j$[1,5,2,0,-5,-2,-1] → 1..2.. -5.. -2.. -1[1,5,2,0,-5,-2,3,-1] → 1..2.. -5.. -2.. 3$\mathcal{O}(n)$

これは、最長増加サブシーケンス問題のバリエーションです。これは、2つの補助配列およびPを使用してウィキペディアに提示されたソリューションです。$M$$P$

• -格納位置 kの最小値の A [ K ]の長さの増加部分列があるように Jで終わる A [ K ]の範囲で K ≤ I（注我々は J ≤ K ≤ Iここで、ので、 jが増加部分列の長さを表し、 kはその終了の位置を表している。もちろん、我々は長さの増加サブ持つことはありません 13位で終わる$M[j]$$k$$A[k]$$j$$A[k]$$k \leq i$$j \leq k \leq i$$j$$k$$13$$11$。の定義によります）。$k \leq i$

• -の前身の格納位置 A [ K ]で終了する最長の増加サブシーケンスにおける A [ K ]。$P[k]$$A[k]$$A[k]$

  さらに、アルゴリズムは、これまでに見つかった最長の増加サブシーケンスの長さを表す変数保存します。$L$

このアルゴリズムは、最悪の場合の時間ます。あなたの問題は、あなたが返すことができます特殊なケースであるとき、L = 3プッシュがまでランタイムO （N ）のバイナリ検索は、時間にそのためである、2最大で長さの配列上でのみ動作しますので、O （1 ）とは対照的に、一般的な場合のΘ （log n ）。$\Theta(n\log n)$$L=3$$O(n)$$O(1)$$\Theta(\log n)$

変更された擬似コードを検討してください。

 L = 0
 for i = 1, 2, ... n:
    binary search for the largest positive j ≤ L
      such that X[M[j]] < X[i] (or set j = 0 if no such value exists)
    P[i] = M[j]
    if j == L or X[i] < X[M[j+1]]:
       M[j+1] = i
       L = max(L, j+1)
   if L==3 : return true; // you can break here, and return true.
return false; // because L is smaller than 3.

方法論に関するメモ

この問題について少し考えて、解決策を見つけました。Saeed Amiriの答えを読んだとき、私が思いついたのは、長さ3のシーケンスの標準的な最長サブシーケンス検索アルゴリズムの特殊バージョンであることに気づきました。問題解決の興味深い例です。

2要素バージョン

$i < j$$A[i] < A[j]$

$A$$\forall i < j, A[i] \ge A[j]$$\forall i, A[i] \ge A[i+1]$$i$$A[i] < A[i+1]$

このケースは非常に簡単です。それを一般化しようとします。記載されている問題は解決できないことを示しています。要求されたインデックスが常に存在するとは限りません。そのため、アルゴリズムが有効なインデックスが存在する場合はそれを返すか、そのようなインデックスが存在しないと正しく主張するように依頼します。

アルゴリズムを考え出す

$A$$(A[i_1],\ldots,A[i_m])$$i_1 < \dots < i_m$$A$$(A[i],A[i+1],\ldots,A[i+m-1])$

要求されたインデックスが常に存在するとは限らないことがわかりました。私たちの戦略は、指標が存在しない場合に研究することです。これを行うには、インデックスを見つけようとして、検索がどのように失敗するかを確認します。次に、検索が失敗しない場合は、インデックスを見つけるためのアルゴリズムを提供します。

$j=i+1$$k=j+1$$A[i] < A[i+1] < A[i+2]$

$A[j] < A[j+1]$$i$$A[i] < A[j]$$k$$A[j+1] < A[k]$

$i$$k$

$i$$j$$k$$i$

$i$$(i,j)$$k$$i$$(i,j)$$(i,j)$$i' > j$$A[i'] < A[i]$$i'$$i$$(i,j)$$j'$$A[j'] < A[j]$$(i',j')$

アルゴリズムの説明

Python構文で与えられますが、テストしていないことに注意してください。

def subsequence3(A):
    """Return the indices of a subsequence of length 3, or None if there is none."""
    index1 = None; value1 = None
    index2 = None; value2 = None
    for i in range(0,len(A)):
        if index1 == None or A[i] < value1:
            index1 = i; value1 = A[i]
        else if A[i] == value1: pass
        else if index2 == None:
            index2 = (index1, i); value2 = (value1, A[i])
        else if A[i] < value2[1]:
            index2[1] = i; value2[1] = A[i]
        else if A[i] > value2[1]:
            return (index2[0], index2[1], i)
    return None

証明スケッチ

index1は、既にトラバースされている配列の部分の最小のインデックスです（複数回出現する場合、最初の出現を保持します）、またはNone最初の要素を処理する前。index2長さが2の増加するサブシーケンスのインデックスを、最小の最大要素を持つ配列の既に通過した部分に格納するかNone、そのようなシーケンスが存在しない場合。

ときにreturn (index2[0], index2[1], i)実行するには、我々が持っているvalue2[0] < value[1]（これはの不変であるvalue2）およびvalue[1] < A[i]（文脈から明らか）。アーリーリターンを呼び出さずにループが終了した場合、の場合、value1 == None長さ2の増加サブシーケンスはありませんvalue1。後者の場合、さらに、長さ3の増加するサブシーケンスがの前に終了しないという不変式がありvalue1ます。したがって、そのようなサブシーケンスの最後の要素は、に追加されvalue2、長さ3の増加するサブシーケンスを形成します：value2配列のすでに通過した部分に含まれる長さ3の増加するサブシーケンスの一部ではない不変量があるため、配列全体にそのようなサブシーケンスはありません。

前述の不変式の証明は、読者の課題として残されています。

複雑

$O(1)$$O(1)$$O(n)$

正式な証明

読者への演習として残しました。

$O(n)$$O(n)$

最初に、スタックと、各要素、それよりも大きい要素のインデックス、およびその右側を示す補助配列を維持しながら、配列を左から右に走査します。

$-1$

配列内の新しい要素を検討するたびに、その要素がスタックの一番上の要素よりも大きい場合、スタックからポップし、一番上の要素に対応する補助配列要素を設定して、新しい要素のインデックスを考慮。

現在の要素が大きい間、スタックから要素をポップし、対応するインデックスを設定し続けます。一番上にある要素がより小さくない（または空になる）と、現在の要素をスタックにプッシュし、配列の次の要素に進み、上記の手順を繰り返します。

別のパス（および別の補助配列）を作成しますが、右から左に進みます。

$-1$

$O(n)$

$k-i$

最初のパスの擬似コードは次のようになります。

Stack <Pair<Elem, Index>> greats;
Elem auxArr[inputArr.Length];

for (Index i = 0; i < inputArr.Length; i++) {

    while (!greats.IsEmpty() && inputArr[i] > greats.PeekTop().Elem) {
        Pair top = greats.Pop();
        auxArr[top.Index] = i;
    }

    Pair p;
    p.Elem = inputArr[i];
    p.Index = i;

    greats.Push(p);
}