Có thuật toán nào tìm thấy các chuỗi được sắp xếp có kích thước ba trong thời gian

Tôi muốn chứng minh hoặc bác bỏ sự tồn tại của một thuật toán, với một mảng gồm các số nguyên, tìm thấy ba chỉ số i , j và k sao cho i < j < k và A [ i ] < A [ j ] < A [ k ] (hoặc thấy rằng không có bộ ba như vậy) trong thời gian tuyến tính.$A$$i, j$$k$$i < j < k$$A[i] < A[j] < A[k]$

Đây không phải là một câu hỏi bài tập về nhà; Tôi thấy nó trên một diễn đàn lập trình được đóng khung khi cố gắng thực hiện một thuật toán như vậy. Tôi nghi ngờ rằng điều đó là không thể sau nhiều thử nghiệm khác nhau. Trực giác của tôi nói với tôi như vậy, nhưng điều đó không thực sự được tính cho bất cứ điều gì.

Tôi muốn chứng minh nó chính thức. Bạn làm nó như thế nào? Tôi lý tưởng muốn thấy một bằng chứng được đưa ra từng bước, và sau đó nếu bạn rất có khuynh hướng, một số giải thích về cách đi về việc chứng minh / từ chối các câu hỏi đơn giản như thế này nói chung. Nếu nó giúp, một số ví dụ:

[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)

Tôi nghĩ rằng người ta có thể lặp lại , và mỗi lần có một i < j ( j hiện tại của chúng tôi ), chúng tôi tạo ra một bộ ba mới và đẩy nó vào một mảng. Chúng tôi tiếp tục bước và so sánh từng bộ ba cho đến khi một trong ba bộ của chúng tôi hoàn thành. Vì vậy, nó như thế , ! Nhưng tôi nghĩ rằng điều này phức tạp hơn chỉ là O ( n ) vì số lượng bộ ba trên mảng ba của chúng tôi trong trường hợp xấu nhất tương ứng với kích thước của danh sách đầu vào.$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)$

Đây là biến thể của vấn đề tiếp theo tăng dài nhất ; đây là giải pháp được trình bày trên Wikipedia bằng hai mảng phụ và P :$M$$P$

• - lưu trữ vị trí k có giá trị nhỏ nhất A [ k ] sao cho có độ dài tăng dần j kết thúc tại A [ k ] trên phạm vi k ≤ i (lưu ý chúng tôi có j ≤ k ≤ i ở đây, bởi vì j đại diện cho độ dài của chuỗi con tăng dần và k đại diện cho vị trí chấm dứt của nó. Rõ ràng, chúng ta không bao giờ có thể có một chuỗi con tăng dài 13 kết thúc ở vị trí$M[j]$$k$$A[k]$$j$$A[k]$$k \leq i$$j \leq k \leq i$$j$$k$$13$$11$. theo định nghĩa).$k \leq i$

• - lưu trữ vị trí của tiền thân của A [ k ] trong chuỗi tăng dài nhất kết thúc tại A [ k ] .$P[k]$$A[k]$$A[k]$

  Ngoài ra, thuật toán lưu trữ một biến đại diện cho độ dài của chuỗi tăng dài nhất được tìm thấy cho đến nay.$L$

Thuật toán này chạy trong trường hợp xấu nhất . Vấn đề của bạn là một trường hợp đặc biệt cho phép bạn quay lại khi L = 3 , điều này đẩy thời gian chạy xuống O ( n ) vì tìm kiếm nhị phân chỉ chạy trên các mảng có độ dài nhiều nhất là hai, do đó trong thời gian O ( 1 ) trái ngược với Θ ( log n ) trong trường hợp tổng quát.$\Theta(n\log n)$$L=3$$O(n)$$O(1)$$\Theta(\log n)$

Hãy xem xét mã giả đã sửa đổi:

 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.

Một lưu ý về phương pháp luận

Tôi nghĩ một chút về vấn đề này, và đi đến một giải pháp. Khi tôi đọc câu trả lời của Saeed Amiri , tôi nhận ra rằng những gì tôi nghĩ ra là một phiên bản chuyên biệt của thuật toán tìm kiếm dài nhất tiêu chuẩn cho một chuỗi dài 3. Tôi đang đăng tải cách tôi đưa ra giải pháp, bởi vì tôi nghĩ nó là một ví dụ thú vị về giải quyết vấn đề.

Phiên bản hai yếu tố

Chúng ta hãy bắt đầu nhỏ: thay vì tìm kiếm ba chỉ số theo đó các phần tử theo thứ tự, chúng ta hãy tìm hai: sao cho A [ i ] < A [ j ] .$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]$

Trường hợp này rất đơn giản; chúng tôi sẽ cố gắng khái quát nó. Nó cho thấy rằng vấn đề như đã nêu là không thể giải quyết được: các chỉ số được yêu cầu không phải lúc nào cũng tồn tại. Vì vậy, chúng tôi sẽ yêu cầu thuật toán trả về các chỉ số hợp lệ, nếu chúng tồn tại hoặc tuyên bố chính xác rằng không có chỉ số nào như vậy tồn tại.

Đến với thuật toán

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

Chúng tôi chỉ thấy rằng các chỉ số được yêu cầu không phải lúc nào cũng tồn tại. Chiến lược của chúng tôi sẽ là nghiên cứu khi các chỉ số không tồn tại. Chúng tôi sẽ làm điều này bằng cách giả sử chúng tôi đang cố gắng tìm các chỉ số và xem cách tìm kiếm của chúng tôi có thể sai. Sau đó, các trường hợp tìm kiếm không sai sẽ cung cấp một thuật toán để tìm các chỉ số.

$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')$

Báo cáo thuật toán

Đưa ra theo cú pháp Python, nhưng hãy cẩn thận mà tôi đã không kiểm tra nó.

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

Bằng chứng phác thảo

index1là chỉ số tối thiểu của một phần của mảng đã được duyệt qua (nếu nó xảy ra nhiều lần, chúng tôi giữ lại lần xuất hiện đầu tiên) hoặc Nonetrước khi xử lý phần tử đầu tiên. index2lưu trữ các chỉ số về độ tăng dần của chiều dài 2 trong phần đã đi qua của mảng có phần tử lớn nhất thấp nhất hoặc Nonenếu một chuỗi như vậy không tồn tại.

Khi return (index2[0], index2[1], i)chạy, chúng ta có value2[0] < value[1](đây là một bất biến value2) và value[1] < A[i](rõ ràng từ bối cảnh). Nếu vòng lặp kết thúc mà không gọi trả về sớm, value1 == Nonethì trong trường hợp đó, không có phần tăng dần của chiều dài 2, hãy để riêng 3 hoặc value1chứa phần tăng dần của chiều dài 2 có phần tử lớn nhất thấp nhất. Trong trường hợp sau, chúng ta còn có một bất biến là không tăng phần sau của chiều dài 3 kết thúc sớm hơn value1; do đó, phần tử cuối cùng của bất kỳ phần tiếp theo nào như vậy, được thêm vào value2, sẽ tạo thành phần tiếp theo tăng dần của chiều dài 3: vì chúng ta cũng có bất biến value2không phải là một phần của phần tiếp theo tăng 3 có trong phần đã đi qua của mảng, ở đó không có như vậy trong toàn bộ mảng.

Chứng minh các bất biến đã nói ở trên là một bài tập cho người đọc.

Phức tạp

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

Bằng chứng chính thức

Còn lại như một bài tập cho người đọc.

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

Đầu tiên, di chuyển mảng từ trái sang phải để duy trì một ngăn xếp và một mảng phụ trợ cho bạn biết từng phần tử, chỉ mục của một phần tử lớn hơn nó và bên phải của nó.

$-1$

Mỗi lần bạn xem xét một phần tử mới trong mảng, nếu phần tử đó lớn hơn phần tử trên cùng của ngăn xếp, bạn bật nó ra khỏi ngăn xếp và đặt phần tử mảng phụ tương ứng với phần trên để có chỉ mục của phần tử mới bên dưới cân nhắc.

Tiếp tục bật các phần tử ra khỏi ngăn xếp và thiết lập chỉ mục tương ứng, trong khi phần tử hiện tại lớn hơn. Khi đỉnh có một phần tử không nhỏ hơn (hoặc trở nên trống rỗng), đẩy phần tử hiện tại lên ngăn xếp và tiến hành phần tử tiếp theo của mảng, lặp lại bước trên.

Thực hiện một đường chuyền khác (và một mảng bổ trợ khác), nhưng đi từ phải sang trái.

$-1$

$O(n)$

$k-i$

Mã giả cho lần đầu tiên có thể trông như thế này:

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);
}