ฉันมีชุดจำนวนเต็ม ฉันต้องการค้นหาชุดลำดับที่เพิ่มขึ้นที่ยาวที่สุดโดยใช้การเขียนโปรแกรมแบบไดนามิก

ตกลงฉันจะอธิบายวิธีแก้ปัญหาที่ง่ายที่สุดอันดับแรกคือ O (N ^ 2) โดยที่ N คือขนาดของคอลเลกชัน นอกจากนี้ยังมีโซลูชัน O (N log N) ซึ่งฉันจะอธิบายด้วย ดูที่นี่ได้ที่ส่วนอัลกอริทึมที่มีประสิทธิภาพ

ผมจะสมมติดัชนีของอาร์เรย์จาก 0 ถึง N - 1. เพื่อให้มีกำหนดDP[i]ที่จะเป็นความยาวของ LIS (ที่ยาวที่สุดที่เพิ่มขึ้น subsequence) iซึ่งกำลังจะสิ้นสุดลงในองค์ประกอบดัชนี ในการคำนวณDP[i]เราดูดัชนีทั้งหมดj < iและตรวจสอบทั้งถ้าDP[j] + 1 > DP[i]และarray[j] < array[i](เราต้องการให้เพิ่มขึ้น) DP[i]ถ้าเป็นจริงเราสามารถอัปเดตที่ดีที่สุดในปัจจุบัน เพื่อหาค่าโกลบอลที่เหมาะสมสำหรับอาเรย์คุณสามารถใช้ค่าสูงสุดDP[0...N - 1]ได้

int maxLength = 1, bestEnd = 0;
DP[0] = 1;
prev[0] = -1;

for (int i = 1; i < N; i++)
{
   DP[i] = 1;
   prev[i] = -1;

   for (int j = i - 1; j >= 0; j--)
      if (DP[j] + 1 > DP[i] && array[j] < array[i])
      {
         DP[i] = DP[j] + 1;
         prev[i] = j;
      }

   if (DP[i] > maxLength)
   {
      bestEnd = i;
      maxLength = DP[i];
   }
}

ฉันใช้อาร์เรย์prevเพื่อหาลำดับที่แท้จริงไม่เพียง แต่ความยาวเท่านั้น เพียงแค่กลับไปซ้ำมาจากในวงโดยใช้bestEnd ค่าเป็นสัญญาณหยุดprev[bestEnd]-1

ตกลงตอนนี้ถึงO(N log N)ทางออกที่มีประสิทธิภาพมากขึ้น:

อนุญาตให้S[pos]กำหนดเป็นจำนวนเต็มที่เล็กที่สุดที่สิ้นสุดลำดับความยาวที่เพิ่มขึ้นpos. ทวนซ้ำผ่านจำนวนเต็มXของชุดอินพุตและทำสิ่งต่อไปนี้:

1. ถ้าX> องค์ประกอบสุดท้ายในSแล้วผนวกที่ส่วนท้ายของX Sสิ่งจำเป็นนี้หมายความว่าเราได้ค้นพบสิ่งใหม่ที่LISยิ่งใหญ่ที่สุด

2. มิฉะนั้นพบว่าองค์ประกอบที่เล็กที่สุดในSซึ่งเป็น>=กว่าและเปลี่ยนเป็นX XเพราะSจะถูกจัดเรียงในเวลาใด ๆ log(N)องค์ประกอบที่สามารถพบได้โดยใช้การค้นหาไบนารีใน

Total runtime - Nจำนวนเต็มและการค้นหาแบบไบนารีสำหรับแต่ละรายการ - N * log (N) = O (N log N)

ตอนนี้ลองทำตัวอย่างจริง:

การเก็บจำนวนเต็ม: 2 6 3 4 1 2 9 5 8

ขั้นตอน:

0. S = {} - Initialize S to the empty set
1. S = {2} - New largest LIS
2. S = {2, 6} - New largest LIS
3. S = {2, 3} - Changed 6 to 3
4. S = {2, 3, 4} - New largest LIS
5. S = {1, 3, 4} - Changed 2 to 1
6. S = {1, 2, 4} - Changed 3 to 2
7. S = {1, 2, 4, 9} - New largest LIS
8. S = {1, 2, 4, 5} - Changed 9 to 5
9. S = {1, 2, 4, 5, 8} - New largest LIS

ดังนั้นความยาวของ LIS คือ5(ขนาดของ S)

หากต้องการสร้างจริงขึ้นมาใหม่LISเราจะใช้อาร์เรย์หลักอีกครั้ง อนุญาตparent[i]เป็นบรรพบุรุษขององค์ประกอบที่มีดัชนีiในตอนจบที่องค์ประกอบที่มีค่าดัชนีLISi

เพื่อให้สิ่งต่าง ๆ ง่ายขึ้นเราสามารถเก็บไว้ในอาร์เรย์Sไม่ใช่จำนวนเต็มจริง แต่เป็นดัชนี (ตำแหน่ง) ในชุด เราจะไม่เก็บแต่เก็บไว้{1, 2, 4, 5, 8}{4, 5, 3, 7, 8}

นั่นคือการป้อนข้อมูล [4] = 1ใส่ [5] = 2เข้า [3] = 4เข้า [7] = 5เข้า [8] = 8

ถ้าเราอัปเดตอาร์เรย์ของ parent อย่างถูกต้อง LIS ที่แท้จริงคือ:

input[S[lastElementOfS]], 
input[parent[S[lastElementOfS]]],
input[parent[parent[S[lastElementOfS]]]],
........................................

ทีนี้สิ่งที่สำคัญ - เราจะอัปเดตอาร์เรย์หลักได้อย่างไร มีสองตัวเลือก:

1. ถ้าX> องค์ประกอบสุดท้ายในแล้วS parent[indexX] = indexLastElementนี่หมายความว่าพาเรนต์ขององค์ประกอบล่าสุดคือองค์ประกอบสุดท้าย เราเพียงแค่ย่อหน้าที่ส่วนท้ายของXS

2. มิฉะนั้นพบว่าดัชนีขององค์ประกอบที่เล็กที่สุดในSซึ่งเป็น>=กว่าและเปลี่ยนเป็นX ที่นี่Xparent[indexX] = S[index - 1]

คำอธิบายของ Petar Minchev ช่วยให้สิ่งต่าง ๆ ชัดเจนขึ้นสำหรับฉัน แต่มันยากสำหรับฉันที่จะวิเคราะห์ว่าทุกอย่างเป็นเช่นไรดังนั้นฉันจึงใช้งาน Python ด้วยชื่อตัวแปรที่อธิบายมากเกินไปและความคิดเห็นมากมาย ฉันใช้โซลูชันเรียกซ้ำแบบไร้เดียงสาโซลูชัน O (n ^ 2) และโซลูชัน O (n log n)

ฉันหวังว่ามันช่วยล้างอัลกอริทึม!

โซลูชันแบบเรียกซ้ำ

def recursive_solution(remaining_sequence, bigger_than=None):
    """Finds the longest increasing subsequence of remaining_sequence that is      
    bigger than bigger_than and returns it.  This solution is O(2^n)."""

    # Base case: nothing is remaining.                                             
    if len(remaining_sequence) == 0:
        return remaining_sequence

    # Recursive case 1: exclude the current element and process the remaining.     
    best_sequence = recursive_solution(remaining_sequence[1:], bigger_than)

    # Recursive case 2: include the current element if it's big enough.            
    first = remaining_sequence[0]

    if (first > bigger_than) or (bigger_than is None):

        sequence_with = [first] + recursive_solution(remaining_sequence[1:], first)

        # Choose whichever of case 1 and case 2 were longer.                         
        if len(sequence_with) >= len(best_sequence):
            best_sequence = sequence_with

    return best_sequence                                                        

โซลูชันการเขียนโปรแกรมแบบไดนามิก O (n ^ 2)

def dynamic_programming_solution(sequence):
    """Finds the longest increasing subsequence in sequence using dynamic          
    programming.  This solution is O(n^2)."""

    longest_subsequence_ending_with = []
    backreference_for_subsequence_ending_with = []
    current_best_end = 0

    for curr_elem in range(len(sequence)):
        # It's always possible to have a subsequence of length 1.                    
        longest_subsequence_ending_with.append(1)

        # If a subsequence is length 1, it doesn't have a backreference.             
        backreference_for_subsequence_ending_with.append(None)

        for prev_elem in range(curr_elem):
            subsequence_length_through_prev = (longest_subsequence_ending_with[prev_elem] + 1)

            # If the prev_elem is smaller than the current elem (so it's increasing)   
            # And if the longest subsequence from prev_elem would yield a better       
            # subsequence for curr_elem.                                               
            if ((sequence[prev_elem] < sequence[curr_elem]) and
                    (subsequence_length_through_prev >
                         longest_subsequence_ending_with[curr_elem])):

                # Set the candidate best subsequence at curr_elem to go through prev.    
                longest_subsequence_ending_with[curr_elem] = (subsequence_length_through_prev)
                backreference_for_subsequence_ending_with[curr_elem] = prev_elem
                # If the new end is the best, update the best.    

        if (longest_subsequence_ending_with[curr_elem] >
                longest_subsequence_ending_with[current_best_end]):
            current_best_end = curr_elem
            # Output the overall best by following the backreferences.  

    best_subsequence = []
    current_backreference = current_best_end

    while current_backreference is not None:
        best_subsequence.append(sequence[current_backreference])
        current_backreference = (backreference_for_subsequence_ending_with[current_backreference])

    best_subsequence.reverse()

    return best_subsequence                                                   

โซลูชันการเขียนโปรแกรมแบบไดนามิก O (n log n)

def find_smallest_elem_as_big_as(sequence, subsequence, elem):
    """Returns the index of the smallest element in subsequence as big as          
    sequence[elem].  sequence[elem] must not be larger than every element in       
    subsequence.  The elements in subsequence are indices in sequence.  Uses       
    binary search."""

    low = 0
    high = len(subsequence) - 1

    while high > low:
        mid = (high + low) / 2
        # If the current element is not as big as elem, throw out the low half of    
        # sequence.                                                                  
        if sequence[subsequence[mid]] < sequence[elem]:
            low = mid + 1
            # If the current element is as big as elem, throw out everything bigger, but 
        # keep the current element.                                                  
        else:
            high = mid

    return high


def optimized_dynamic_programming_solution(sequence):
    """Finds the longest increasing subsequence in sequence using dynamic          
    programming and binary search (per                                             
    http://en.wikipedia.org/wiki/Longest_increasing_subsequence).  This solution   
    is O(n log n)."""

    # Both of these lists hold the indices of elements in sequence and not the        
    # elements themselves.                                                         
    # This list will always be sorted.                                             
    smallest_end_to_subsequence_of_length = []

    # This array goes along with sequence (not                                     
    # smallest_end_to_subsequence_of_length).  Following the corresponding element 
    # in this array repeatedly will generate the desired subsequence.              
    parent = [None for _ in sequence]

    for elem in range(len(sequence)):
        # We're iterating through sequence in order, so if elem is bigger than the   
        # end of longest current subsequence, we have a new longest increasing          
        # subsequence.                                                               
        if (len(smallest_end_to_subsequence_of_length) == 0 or
                    sequence[elem] > sequence[smallest_end_to_subsequence_of_length[-1]]):
            # If we are adding the first element, it has no parent.  Otherwise, we        
            # need to update the parent to be the previous biggest element.            
            if len(smallest_end_to_subsequence_of_length) > 0:
                parent[elem] = smallest_end_to_subsequence_of_length[-1]
            smallest_end_to_subsequence_of_length.append(elem)
        else:
            # If we can't make a longer subsequence, we might be able to make a        
            # subsequence of equal size to one of our earlier subsequences with a         
            # smaller ending number (which makes it easier to find a later number that 
            # is increasing).                                                          
            # Thus, we look for the smallest element in                                
            # smallest_end_to_subsequence_of_length that is at least as big as elem       
            # and replace it with elem.                                                
            # This preserves correctness because if there is a subsequence of length n 
            # that ends with a number smaller than elem, we could add elem on to the   
            # end of that subsequence to get a subsequence of length n+1.              
            location_to_replace = find_smallest_elem_as_big_as(sequence, smallest_end_to_subsequence_of_length, elem)
            smallest_end_to_subsequence_of_length[location_to_replace] = elem
            # If we're replacing the first element, we don't need to update its parent 
            # because a subsequence of length 1 has no parent.  Otherwise, its parent  
            # is the subsequence one shorter, which we just added onto.                
            if location_to_replace != 0:
                parent[elem] = (smallest_end_to_subsequence_of_length[location_to_replace - 1])

    # Generate the longest increasing subsequence by backtracking through parent.  
    curr_parent = smallest_end_to_subsequence_of_length[-1]
    longest_increasing_subsequence = []

    while curr_parent is not None:
        longest_increasing_subsequence.append(sequence[curr_parent])
        curr_parent = parent[curr_parent]

    longest_increasing_subsequence.reverse()

    return longest_increasing_subsequence         

พูดเกี่ยวกับการแก้ปัญหา DP ผมพบว่ามันน่าแปลกใจที่ไม่มีใครกล่าวถึงความจริงที่ว่า LIS สามารถลดลงได้LCS สิ่งที่คุณต้องทำคือเรียงลำดับสำเนาต้นฉบับลบรายการที่ซ้ำกันทั้งหมดและทำ LCS ของพวกเขา ใน pseudocode มันคือ:

def LIS(S):
    T = sort(S)
    T = removeDuplicates(T)
    return LCS(S, T)

และการใช้งานเต็มรูปแบบเขียนใน Go คุณไม่จำเป็นต้องบำรุงรักษาทั้งเมทริกซ์ n ^ 2 DP หากคุณไม่จำเป็นต้องสร้างโซลูชันขึ้นใหม่

func lcs(arr1 []int) int {
    arr2 := make([]int, len(arr1))
    for i, v := range arr1 {
        arr2[i] = v
    }
    sort.Ints(arr1)
    arr3 := []int{}
    prev := arr1[0] - 1
    for _, v := range arr1 {
        if v != prev {
            prev = v
            arr3 = append(arr3, v)
        }
    }

    n1, n2 := len(arr1), len(arr3)

    M := make([][]int, n2 + 1)
    e := make([]int, (n1 + 1) * (n2 + 1))
    for i := range M {
        M[i] = e[i * (n1 + 1):(i + 1) * (n1 + 1)]
    }

    for i := 1; i <= n2; i++ {
        for j := 1; j <= n1; j++ {
            if arr2[j - 1] == arr3[i - 1] {
                M[i][j] = M[i - 1][j - 1] + 1
            } else if M[i - 1][j] > M[i][j - 1] {
                M[i][j] = M[i - 1][j]
            } else {
                M[i][j] = M[i][j - 1]
            }
        }
    }

    return M[n2][n1]
}

ต่อไปนี้ C ++ การดำเนินงานยังรวมถึงรหัสที่สร้างจริงเพิ่มขึ้น subsequence ที่ยาวที่สุดprevใช้อาร์เรย์ที่เรียกว่า

std::vector<int> longest_increasing_subsequence (const std::vector<int>& s)
{
    int best_end = 0;
    int sz = s.size();

    if (!sz)
        return std::vector<int>();

    std::vector<int> prev(sz,-1);
    std::vector<int> memo(sz, 0);

    int max_length = std::numeric_limits<int>::min();

    memo[0] = 1;

    for ( auto i = 1; i < sz; ++i)
    {
        for ( auto j = 0; j < i; ++j)
        {
            if ( s[j] < s[i] && memo[i] < memo[j] + 1 )
            {
                memo[i] =  memo[j] + 1;
                prev[i] =  j;
            }
        }

        if ( memo[i] > max_length ) 
        {
            best_end = i;
            max_length = memo[i];
        }
    }

    // Code that builds the longest increasing subsequence using "prev"
    std::vector<int> results;
    results.reserve(sz);

    std::stack<int> stk;
    int current = best_end;

    while (current != -1)
    {
        stk.push(s[current]);
        current = prev[current];
    }

    while (!stk.empty())
    {
        results.push_back(stk.top());
        stk.pop();
    }

    return results;
}

การใช้งานโดยไม่มีสแต็กเพียงแค่ย้อนกลับเวกเตอร์

#include <iostream>
#include <vector>
#include <limits>
std::vector<int> LIS( const std::vector<int> &v ) {
  auto sz = v.size();
  if(!sz)
    return v;
  std::vector<int> memo(sz, 0);
  std::vector<int> prev(sz, -1);
  memo[0] = 1;
  int best_end = 0;
  int max_length = std::numeric_limits<int>::min();
  for (auto i = 1; i < sz; ++i) {
    for ( auto j = 0; j < i ; ++j) {
      if (s[j] < s[i] && memo[i] < memo[j] + 1) {
        memo[i] = memo[j] + 1;
        prev[i] = j;
      }
    }
    if(memo[i] > max_length) {
      best_end = i;
      max_length = memo[i];
    }
  }

  // create results
  std::vector<int> results;
  results.reserve(v.size());
  auto current = best_end;
  while (current != -1) {
    results.push_back(s[current]);
    current = prev[current];
  }
  std::reverse(results.begin(), results.end());
  return results;
}

นี่คือสามขั้นตอนในการประเมินปัญหาจากมุมมองการเขียนโปรแกรมแบบไดนามิก:

1. นิยามการเกิดซ้ำ: maxLength (i) == 1 + maxLength (j) โดยที่ 0 <j <i และ array [i]> array [j]
2. ขอบเขตพารามิเตอร์การเกิดซ้ำ: อาจมี 0 ถึง i - 1 ลำดับย่อยส่งผ่านเป็นพารามิเตอร์
3. ลำดับการประเมินผล: เนื่องจากกำลังเพิ่มลำดับย่อยจึงต้องมีการประเมินจาก 0 ถึง n

ถ้าเราใช้ลำดับตัวอย่าง {0, 8, 2, 3, 7, 9} ที่ index:

• [0] เราจะได้ลำดับ {0} เป็นกรณีพื้นฐาน
• [1] เรามี 1 องค์ประกอบใหม่ {0, 8}
• [2] พยายามประเมินสองลำดับใหม่ {0, 8, 2} และ {0, 2} โดยการเพิ่มองค์ประกอบที่ดัชนี 2 ไปยังลำดับย่อยที่มีอยู่ - มีเพียงรายการเดียวเท่านั้นที่ถูกต้องดังนั้นการเพิ่มลำดับที่สามที่เป็นไปได้ {0, 2} เท่านั้น ไปยังรายการพารามิเตอร์ ...

นี่คือรหัส C ++ 11 ที่ใช้งานได้:

#include <iostream>
#include <vector>

int getLongestIncSub(const std::vector<int> &sequence, size_t index, std::vector<std::vector<int>> &sub) {
    if(index == 0) {
        sub.push_back(std::vector<int>{sequence[0]});
        return 1;
    }

    size_t longestSubSeq = getLongestIncSub(sequence, index - 1, sub);
    std::vector<std::vector<int>> tmpSubSeq;
    for(std::vector<int> &subSeq : sub) {
        if(subSeq[subSeq.size() - 1] < sequence[index]) {
            std::vector<int> newSeq(subSeq);
            newSeq.push_back(sequence[index]);
            longestSubSeq = std::max(longestSubSeq, newSeq.size());
            tmpSubSeq.push_back(newSeq);
        }
    }
    std::copy(tmpSubSeq.begin(), tmpSubSeq.end(),
              std::back_insert_iterator<std::vector<std::vector<int>>>(sub));

    return longestSubSeq;
}

int getLongestIncSub(const std::vector<int> &sequence) {
    std::vector<std::vector<int>> sub;
    return getLongestIncSub(sequence, sequence.size() - 1, sub);
}

int main()
{
    std::vector<int> seq{0, 8, 2, 3, 7, 9};
    std::cout << getLongestIncSub(seq);
    return 0;
}

นี่คือการใช้ Scala ของอัลกอริทึม O (n ^ 2):

object Solve {
  def longestIncrSubseq[T](xs: List[T])(implicit ord: Ordering[T]) = {
    xs.foldLeft(List[(Int, List[T])]()) {
      (sofar, x) =>
        if (sofar.isEmpty) List((1, List(x)))
        else {
          val resIfEndsAtCurr = (sofar, xs).zipped map {
            (tp, y) =>
              val len = tp._1
              val seq = tp._2
              if (ord.lteq(y, x)) {
                (len + 1, x :: seq) // reversely recorded to avoid O(n)
              } else {
                (1, List(x))
              }
          }
          sofar :+ resIfEndsAtCurr.maxBy(_._1)
        }
    }.maxBy(_._1)._2.reverse
  }

  def main(args: Array[String]) = {
    println(longestIncrSubseq(List(
      0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15)))
  }
}

นี่คือการติดตั้ง JAVA O (n ^ 2) อีกรายการ ไม่มีการเรียกซ้ำ / บันทึกช่วยจำในการสร้างลำดับที่แท้จริง เพียงแค่อาร์เรย์สตริงที่จัดเก็บ LIS จริงในทุกขั้นตอนและอาร์เรย์เพื่อเก็บความยาวของ LIS สำหรับแต่ละองค์ประกอบ คำสาปสวยง่าย ไปดูกัน:

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * Created by Shreyans on 4/16/2015
 */

class LNG_INC_SUB//Longest Increasing Subsequence
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter Numbers Separated by Spaces to find their LIS\n");
        String[] s1=br.readLine().split(" ");
        int n=s1.length;
        int[] a=new int[n];//Array actual of Numbers
        String []ls=new String[n];// Array of Strings to maintain LIS for every element
        for(int i=0;i<n;i++)
        {
            a[i]=Integer.parseInt(s1[i]);
        }
        int[]dp=new int[n];//Storing length of max subseq.
        int max=dp[0]=1;//Defaults
        String seq=ls[0]=s1[0];//Defaults
        for(int i=1;i<n;i++)
        {
            dp[i]=1;
            String x="";
            for(int j=i-1;j>=0;j--)
            {
                //First check if number at index j is less than num at i.
                // Second the length of that DP should be greater than dp[i]
                // -1 since dp of previous could also be one. So we compare the dp[i] as empty initially
                if(a[j]<a[i]&&dp[j]>dp[i]-1)
                {
                    dp[i]=dp[j]+1;//Assigning temp length of LIS. There may come along a bigger LIS of a future a[j]
                    x=ls[j];//Assigning temp LIS of a[j]. Will append a[i] later on
                }
            }
            x+=(" "+a[i]);
            ls[i]=x;
            if(dp[i]>max)
            {
                max=dp[i];
                seq=ls[i];
            }
        }
        System.out.println("Length of LIS is: " + max + "\nThe Sequence is: " + seq);
    }
}

โค้ดที่ใช้งานได้: http://ideone.com/sBiOQx

สิ่งนี้สามารถแก้ไขได้ใน O (n ^ 2) โดยใช้ Dynamic Programming รหัสไพ ธ อนเดียวกันจะเป็นเช่น: -

def LIS(numlist):
    LS = [1]
    for i in range(1, len(numlist)):
        LS.append(1)
        for j in range(0, i):
            if numlist[i] > numlist[j] and LS[i]<=LS[j]:
                LS[i] = 1 + LS[j]
    print LS
    return max(LS)

numlist = map(int, raw_input().split(' '))
print LIS(numlist)

สำหรับอินพุต:5 19 5 81 50 28 29 1 83 23

การส่งออกจะเป็น:[1, 2, 1, 3, 3, 3, 4, 1, 5, 3] 5

list_index ของรายการผลลัพธ์คือ list_index ของรายการอินพุต ค่าที่ list_index ที่กำหนดในรายการผลลัพธ์หมายถึงความยาวการเรียงลำดับที่ยาวที่สุดที่เพิ่มขึ้นสำหรับ list_index นั้น

นี่คือการใช้งาน Java O (nlogn)

import java.util.Scanner;

public class LongestIncreasingSeq {


    private static int binarySearch(int table[],int a,int len){

        int end = len-1;
        int beg = 0;
        int mid = 0;
        int result = -1;
        while(beg <= end){
            mid = (end + beg) / 2;
            if(table[mid] < a){
                beg=mid+1;
                result = mid;
            }else if(table[mid] == a){
                return len-1;
            }else{
                end = mid-1;
            }
        }
        return result;
    }

    public static void main(String[] args) {        

//        int[] t = {1, 2, 5,9,16};
//        System.out.println(binarySearch(t , 9, 5));
        Scanner in = new Scanner(System.in);
        int size = in.nextInt();//4;

        int A[] = new int[size];
        int table[] = new int[A.length]; 
        int k = 0;
        while(k<size){
            A[k++] = in.nextInt();
            if(k<size-1)
                in.nextLine();
        }        
        table[0] = A[0];
        int len = 1; 
        for (int i = 1; i < A.length; i++) {
            if(table[0] > A[i]){
                table[0] = A[i];
            }else if(table[len-1]<A[i]){
                table[len++]=A[i];
            }else{
                table[binarySearch(table, A[i],len)+1] = A[i];
            }            
        }
        System.out.println(len);
    }    
}

นี่เป็นการนำ Java ไปใช้ใน O (n ^ 2) ฉันไม่ได้ใช้การค้นหาแบบไบนารีเพื่อค้นหาองค์ประกอบที่เล็กที่สุดใน S ซึ่ง>> = กว่า X ฉันใช้ a สำหรับลูป การใช้การค้นหาแบบไบนารีจะทำให้ความซับซ้อนที่ O (n logn)

public static void olis(int[] seq){

    int[] memo = new int[seq.length];

    memo[0] = seq[0];
    int pos = 0;

    for (int i=1; i<seq.length; i++){

        int x = seq[i];

            if (memo[pos] < x){ 
                pos++;
                memo[pos] = x;
            } else {

                for(int j=0; j<=pos; j++){
                    if (memo[j] >= x){
                        memo[j] = x;
                        break;
                    }
                }
            }
            //just to print every step
            System.out.println(Arrays.toString(memo));
    }

    //the final array with the LIS
    System.out.println(Arrays.toString(memo));
    System.out.println("The length of lis is " + (pos + 1));

}

ชำระเงินรหัสในจาวาสำหรับลำดับที่เพิ่มขึ้นที่ยาวที่สุดกับองค์ประกอบอาร์เรย์

http://ideone.com/Nd2eba

/**
 **    Java Program to implement Longest Increasing Subsequence Algorithm
 **/

import java.util.Scanner;

/** Class  LongestIncreasingSubsequence **/
 class  LongestIncreasingSubsequence
{
    /** function lis **/
    public int[] lis(int[] X)
    {        
        int n = X.length - 1;
        int[] M = new int[n + 1];  
        int[] P = new int[n + 1]; 
        int L = 0;

        for (int i = 1; i < n + 1; i++)
        {
            int j = 0;

            /** Linear search applied here. Binary Search can be applied too.
                binary search for the largest positive j <= L such that 
                X[M[j]] < X[i] (or set j = 0 if no such value exists) **/

            for (int pos = L ; pos >= 1; pos--)
            {
                if (X[M[pos]] < X[i])
                {
                    j = pos;
                    break;
                }
            }            
            P[i] = M[j];
            if (j == L || X[i] < X[M[j + 1]])
            {
                M[j + 1] = i;
                L = Math.max(L,j + 1);
            }
        }

        /** backtrack **/

        int[] result = new int[L];
        int pos = M[L];
        for (int i = L - 1; i >= 0; i--)
        {
            result[i] = X[pos];
            pos = P[pos];
        }
        return result;             
    }

    /** Main Function **/
    public static void main(String[] args) 
    {    
        Scanner scan = new Scanner(System.in);
        System.out.println("Longest Increasing Subsequence Algorithm Test\n");

        System.out.println("Enter number of elements");
        int n = scan.nextInt();
        int[] arr = new int[n + 1];
        System.out.println("\nEnter "+ n +" elements");
        for (int i = 1; i <= n; i++)
            arr[i] = scan.nextInt();

        LongestIncreasingSubsequence obj = new LongestIncreasingSubsequence(); 
        int[] result = obj.lis(arr);       

        /** print result **/ 

        System.out.print("\nLongest Increasing Subsequence : ");
        for (int i = 0; i < result.length; i++)
            System.out.print(result[i] +" ");
        System.out.println();
    }
}

สิ่งนี้สามารถแก้ไขได้ใน O (n ^ 2) โดยใช้การเขียนโปรแกรมแบบไดนามิก

ประมวลผลองค์ประกอบการป้อนข้อมูลตามลำดับและรักษารายการของสิ่งอันดับสำหรับแต่ละองค์ประกอบ แต่ละ tuple (A, B) สำหรับองค์ประกอบ i จะหมายถึง A = ความยาวของการเพิ่มลำดับย่อยที่ยาวที่สุดที่ i และ B = ดัชนีของบรรพบุรุษของรายการ [i] ในการเพิ่มลำดับย่อยที่ยาวที่สุดที่รายการ [i ]

เริ่มจากองค์ประกอบที่ 1 รายการของ tuple สำหรับองค์ประกอบที่ 1 จะเป็น [(1,0)] สำหรับองค์ประกอบ i สแกนรายการ 0..i และค้นหารายการองค์ประกอบ [k] เช่นนั้นรายการ [k] <รายการ [i] ค่าของ A สำหรับองค์ประกอบ i, Ai จะเป็น Ak + 1 และ Bi จะเป็น k หากมีองค์ประกอบหลายอย่างให้เพิ่มเข้าในรายการสิ่งอันดับสำหรับองค์ประกอบ i

ในที่สุดค้นหาองค์ประกอบทั้งหมดที่มีค่าสูงสุด A (ความยาวของ LIS ที่สิ้นสุดที่องค์ประกอบ) และ backtrack โดยใช้ tuples เพื่อรับรายการ

ฉันแบ่งปันรหัสเดียวกันที่http://www.edufyme.com/code/?id=66f041e16a60928b05a7e228a89c3799

การประยุกต์ใช้จาวา O (n ^ 2):

void LIS(int arr[]){
        int maxCount[]=new int[arr.length];
        int link[]=new int[arr.length];
        int maxI=0;
        link[0]=0;
        maxCount[0]=0;

        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                if(arr[j]<arr[i] && ((maxCount[j]+1)>maxCount[i])){
                    maxCount[i]=maxCount[j]+1;
                    link[i]=j;
                    if(maxCount[i]>maxCount[maxI]){
                        maxI=i;
                    }
                }
            }
        }


        for (int i = 0; i < link.length; i++) {
            System.out.println(arr[i]+"   "+link[i]);
        }
        print(arr,maxI,link);

    }

    void print(int arr[],int index,int link[]){
        if(link[index]==index){
            System.out.println(arr[index]+" ");
            return;
        }else{
            print(arr, link[index], link);
            System.out.println(arr[index]+" ");
        }
    }

def longestincrsub(arr1):
    n=len(arr1)
    l=[1]*n
    for i in range(0,n):
        for j in range(0,i)  :
            if arr1[j]<arr1[i] and l[i]<l[j] + 1:
                l[i] =l[j] + 1
    l.sort()
    return l[-1]
arr1=[10,22,9,33,21,50,41,60]
a=longestincrsub(arr1)
print(a)

แม้ว่าจะมีวิธีที่คุณสามารถแก้ปัญหานี้ในเวลา O (nlogn) (วิธีนี้จะแก้ปัญหาในเวลา O (n ^ 2)) แต่วิธีนี้ยังให้วิธีการเขียนโปรแกรมแบบไดนามิกซึ่งเป็นสิ่งที่ดี

นี่คือโซลูชัน Leetcode ของฉันโดยใช้การค้นหาแบบไบนารี: ->

class Solution:
    def binary_search(self,s,x):
        low=0
        high=len(s)-1
        flag=1
        while low<=high:
              mid=(high+low)//2
              if s[mid]==x:
                 flag=0
                 break
              elif s[mid]<x:
                  low=mid+1
              else:
                 high=mid-1
        if flag:
           s[low]=x
        return s

    def lengthOfLIS(self, nums: List[int]) -> int:
         if not nums:
            return 0
         s=[]
         s.append(nums[0])
         for i in range(1,len(nums)):
             if s[-1]<nums[i]:
                s.append(nums[i])
             else:
                 s=self.binary_search(s,nums[i])
         return len(s)

โซลูชัน LIS ที่ง่ายที่สุดใน C ++ พร้อมความซับซ้อนของเวลา O (nlog (n))

#include <iostream>
#include "vector"
using namespace std;

// binary search (If value not found then it will return the index where the value should be inserted)
int ceilBinarySearch(vector<int> &a,int beg,int end,int value)
{
    if(beg<=end)
    {
        int mid = (beg+end)/2;
        if(a[mid] == value)
            return mid;
        else if(value < a[mid])
            return ceilBinarySearch(a,beg,mid-1,value);
        else
            return ceilBinarySearch(a,mid+1,end,value);

    return 0;
    }

    return beg;

}
int lis(vector<int> arr)
{
    vector<int> dp(arr.size(),0);
    int len = 0;
    for(int i = 0;i<arr.size();i++)
    {
        int j = ceilBinarySearch(dp,0,len-1,arr[i]);
        dp[j] = arr[i];
        if(j == len)
            len++;

    }
    return len;
}

int main()
{
    vector<int> arr  {2, 5,-1,0,6,1,2};
    cout<<lis(arr);
    return 0;
}

ผลลัพธ์:
4

ผลสืบเนื่องที่เพิ่มขึ้นยาวนานที่สุด (Java)

import java.util.*;

class ChainHighestValue implements Comparable<ChainHighestValue>{
    int highestValue;
    int chainLength;
    ChainHighestValue(int highestValue,int chainLength) {
        this.highestValue = highestValue;
        this.chainLength = chainLength;
    }
    @Override
    public int compareTo(ChainHighestValue o) {
       return this.chainLength-o.chainLength;
    }

}


public class LongestIncreasingSubsequenceLinkedList {


    private static LinkedList<Integer> LongestSubsequent(int arr[], int size){
        ArrayList<LinkedList<Integer>> seqList=new ArrayList<>();
        ArrayList<ChainHighestValue> valuePairs=new ArrayList<>();
        for(int i=0;i<size;i++){
            int currValue=arr[i];
            if(valuePairs.size()==0){
                LinkedList<Integer> aList=new LinkedList<>();
                aList.add(arr[i]);
                seqList.add(aList);
                valuePairs.add(new ChainHighestValue(arr[i],1));

            }else{
                try{
                    ChainHighestValue heighestIndex=valuePairs.stream().filter(e->e.highestValue<currValue).max(ChainHighestValue::compareTo).get();
                    int index=valuePairs.indexOf(heighestIndex);
                    seqList.get(index).add(arr[i]);
                    heighestIndex.highestValue=arr[i];
                    heighestIndex.chainLength+=1;

                }catch (Exception e){
                    LinkedList<Integer> aList=new LinkedList<>();
                    aList.add(arr[i]);
                    seqList.add(aList);
                    valuePairs.add(new ChainHighestValue(arr[i],1));
                }
            }
        }
        ChainHighestValue heighestIndex=valuePairs.stream().max(ChainHighestValue::compareTo).get();
        int index=valuePairs.indexOf(heighestIndex);
        return seqList.get(index);
    }

    public static void main(String[] args){
        int arry[]={5,1,3,6,11,30,32,5,3,73,79};
        //int arryB[]={3,1,5,2,6,4,9};
        LinkedList<Integer> LIS=LongestSubsequent(arry, arry.length);
        System.out.println("Longest Incrementing Subsequence:");
        for(Integer a: LIS){
            System.out.print(a+" ");
        }

    }
}

ฉันใช้ LIS เป็นภาษาจาวาโดยใช้ Dynamic Programming and Memoization พร้อมกับรหัสที่ฉันได้ทำการคำนวณความซับซ้อนเช่นทำไมมันเป็น O (n Log (base2) n) เนื่องจากฉันรู้สึกว่าคำอธิบายเชิงทฤษฎีหรือตรรกะนั้นดี แต่การสาธิตในทางปฏิบัตินั้นดีกว่าสำหรับความเข้าใจอยู่เสมอ

package com.company.dynamicProgramming;

import java.util.HashMap;
import java.util.Map;

public class LongestIncreasingSequence {

    static int complexity = 0;

    public static void main(String ...args){


        int[] arr = {10, 22, 9, 33, 21, 50, 41, 60, 80};
        int n = arr.length;

        Map<Integer, Integer> memo = new HashMap<>();

        lis(arr, n, memo);

        //Display Code Begins
        int x = 0;
        System.out.format("Longest Increasing Sub-Sequence with size %S is -> ",memo.get(n));
        for(Map.Entry e : memo.entrySet()){

            if((Integer)e.getValue() > x){
                System.out.print(arr[(Integer)e.getKey()-1] + " ");
                x++;
            }
        }
        System.out.format("%nAnd Time Complexity for Array size %S is just %S ", arr.length, complexity );
        System.out.format( "%nWhich is equivalent to O(n Log n) i.e. %SLog(base2)%S is %S",arr.length,arr.length, arr.length * Math.ceil(Math.log(arr.length)/Math.log(2)));
        //Display Code Ends

    }



    static int lis(int[] arr, int n, Map<Integer, Integer> memo){

        if(n==1){
            memo.put(1, 1);
            return 1;
        }

        int lisAti;
        int lisAtn = 1;

        for(int i = 1; i < n; i++){
            complexity++;

            if(memo.get(i)!=null){
                lisAti = memo.get(i);
            }else {
                lisAti = lis(arr, i, memo);
            }

            if(arr[i-1] < arr[n-1] && lisAti +1 > lisAtn){
                lisAtn = lisAti +1;
            }
        }

        memo.put(n, lisAtn);
        return lisAtn;

    }
}

ในขณะที่ฉันวิ่งรหัสข้างต้น -

Longest Increasing Sub-Sequence with size 6 is -> 10 22 33 50 60 80 
And Time Complexity for Array size 9 is just 36 
Which is equivalent to O(n Log n) i.e. 9Log(base2)9 is 36.0
Process finished with exit code 0

วิธี O (NLog (N)) วิธีการหาลำดับย่อยที่เพิ่มขึ้นยาวที่สุด
ให้เรารักษาอาร์เรย์ที่องค์ประกอบ ith เป็นจำนวนที่เล็กที่สุดที่เป็นไปได้ซึ่งลำดับย่อย ai ที่มีขนาดสามารถสิ้นสุดได้

ฉันตั้งใจหลีกเลี่ยงรายละเอียดเพิ่มเติมเนื่องจากคำตอบที่ได้รับการโหวตแล้วอธิบายไว้แล้ว แต่ในที่สุดเทคนิคนี้นำไปสู่การนำไปปฏิบัติอย่างเป็นระเบียบโดยใช้โครงสร้างข้อมูลชุด (อย่างน้อยใน c ++)

นี่คือการใช้งานใน c ++ (สมมติว่าจำเป็นต้องเพิ่มขนาดของลำดับย่อยที่ยาวที่สุด)

#include <bits/stdc++.h> // gcc supported header to include (almost) everything
using namespace std;
typedef long long ll;

int main()
{
  ll n;
  cin >> n;
  ll arr[n];
  set<ll> S;

  for(ll i=0; i<n; i++)
  {
    cin >> arr[i];
    auto it = S.lower_bound(arr[i]);
    if(it != S.end())
      S.erase(it);
    S.insert(arr[i]);
  }

  cout << S.size() << endl; // Size of the set is the required answer

  return 0;
}