Comment déterminer la sous-séquence croissante la plus longue en utilisant la programmation dynamique?

Réponses:

404

OK, je vais d'abord décrire la solution la plus simple qui est O (N ^ 2), où N est la taille de la collection. Il existe également une solution O (N log N), que je décrirai également. Recherchez-le ici dans la section Algorithmes efficaces.

Je suppose que les indices du tableau sont de 0 à N - 1. Définissons DP[i]donc la longueur de la LIS (sous-séquence croissante la plus longue) qui se termine à l'élément avec l'index i. Pour calculer, DP[i]nous regardons tous les indices j < iet vérifions à la fois si DP[j] + 1 > DP[i]et array[j] < array[i](nous voulons qu'il augmente). Si cela est vrai, nous pouvons mettre à jour l'optimum actuel pour DP[i]. Pour trouver l'optimum global pour la matrice, vous pouvez prendre la valeur maximale de 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];
   }
}

J'utilise le tableau prevpour pouvoir plus tard trouver la séquence réelle non seulement sa longueur. Il suffit de revenir récursivement bestEnddans une boucle en utilisant prev[bestEnd]. La -1valeur est un signe d'arrêt.


OK, maintenant à la O(N log N)solution la plus efficace :

Soit S[pos]défini comme le plus petit entier qui termine une séquence croissante de longueur pos. Maintenant, parcourez chaque entier Xde l'ensemble d'entrée et procédez comme suit:

  1. Si X> dernier élément dans S, ajoutez Xà la fin de S. Cela signifie essentiellement que nous avons trouvé un nouveau plus grand LIS.

  2. Sinon, recherchez le plus petit élément dans S, qui est >=que X, et changez-le en X. Parce qu'il Sest trié à tout moment, l'élément peut être trouvé à l'aide de la recherche binaire dans log(N).

Runtime total - Nentiers et recherche binaire pour chacun d'eux - N * log (N) = O (N log N)

Faisons maintenant un vrai exemple:

Collection d'entiers: 2 6 3 4 1 2 9 5 8

Pas:

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

La longueur du LIS est donc 5(la taille de S).

Pour reconstruire le réel, LISnous utiliserons à nouveau un tableau parent. Soit parent[i]le prédécesseur de l'élément avec index ià la LISfin de l'élément avec index i.

Pour simplifier les choses, nous pouvons conserver dans le tableau S, non pas les entiers réels, mais leurs indices (positions) dans l'ensemble. Nous ne gardons pas {1, 2, 4, 5, 8}, mais gardons {4, 5, 3, 7, 8}.

C'est-à-dire entrée [4] = 1 , entrée [5] = 2 , entrée [3] = 4 , entrée [7] = 5 , entrée [8] = 8 .

Si nous mettons à jour correctement le tableau parent, le LIS réel est:

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

Passons maintenant à l'important - comment mettre à jour le tableau parent? Il y a deux options:

  1. Si X> dernier élément dans S, alors parent[indexX] = indexLastElement. Cela signifie que le parent de l'élément le plus récent est le dernier élément. Nous ajoutons juste Xà la fin de S.

  2. Sinon, recherchez l'index du plus petit élément dans S, qui est >=que X, et changez-le en X. Ici parent[indexX] = S[index - 1].

Petar Minchev
la source
4
Ça n'a pas d'importance. Si DP[j] + 1 == DP[i]alors DP[i]ne deviendra pas meilleur avec DP[i] = DP[j] + 1. Nous essayons d'optimiser DP[i].
Petar Minchev
11
Mais ici, la réponse devrait être [1,2,5,8]: 4 vient avant 1 dans le tableau, comment le LIS peut [1,2,4,5,8]-il être ?
SexyBeast
19
@Cupidvogel - La réponse est [2,3,4,5,8]. Lisez attentivement - le Stableau DOES NOTreprésente une séquence réelle. Let S[pos] be defined as the smallest integer that ends an increasing sequence of length pos.
Petar Minchev
8
Je ne vois pas souvent d'explications aussi claires. Non seulement il est très facile à comprendre, car les doutes sont levés dans l'explication, mais il résout également tout problème de mise en œuvre qui pourrait survenir. Impressionnant.
Boyang
16
geeksforgeeks.org/… est probablement la meilleure explication de cela que j'ai vu
eb80
57

L'explication de Petar Minchev m'a aidé à clarifier les choses, mais il était difficile pour moi d'analyser ce que tout était, alors j'ai fait une implémentation Python avec des noms de variables trop descriptifs et beaucoup de commentaires. J'ai fait une solution récursive naïve, la solution O (n ^ 2) et la solution O (n log n).

J'espère que cela aide à clarifier les algorithmes!

La solution récursive

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                                                        

La solution de programmation dynamique 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                                                   

La solution de programmation dynamique 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         
Sam King
la source
19
Bien que j'apprécie l'effort ici, mes yeux me font mal quand je regarde ces pseudo-codes.
mostruash
94
mostruash - Je ne sais pas ce que tu veux dire. Ma réponse n'a pas de pseudo-code; il a Python.
Sam King
10
Eh bien, il signifie probablement votre convention de dénomination des variables et des fonctions, ce qui a également fait mal aux yeux
Adilli Adil
19
Si vous voulez dire ma convention de dénomination, je suis principalement le guide de style Google Python. Si vous préconisez des noms de variables courts, je préfère les noms de variables descriptives car ils facilitent la compréhension et la maintenance du code.
Sam King
10
Pour une implémentation réelle, il serait probablement judicieux d'utiliser bisect. Pour une démonstration du fonctionnement d'un algorithme et de ses caractéristiques de performance, j'essayais de garder les choses aussi primitives que possible.
Sam King
22

En parlant de la solution DP, j'ai trouvé surprenant que personne n'ait mentionné le fait que LIS puisse être réduit à LCS . Tout ce que vous avez à faire est de trier la copie de la séquence d'origine, de supprimer tous les doublons et d'en faire LCS. En pseudocode c'est:

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

Et l'implémentation complète écrite en Go. Vous n'avez pas besoin de conserver l'intégralité de la matrice n ^ 2 DP si vous n'avez pas besoin de reconstruire la solution.

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]
}
Salvador Dali
la source
@max oui, c'est un peu écrit dans la réponse avec LCS, matrice n ^ 2
Salvador Dali
10

L'implémentation C ++ suivante inclut également du code qui crée la sous- séquence croissante la plus longue réelle à l' aide d'un tableau appelé 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;
}

Implémentation sans pile inversez simplement le vecteur

#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;
}
bjackfly
la source
4

Voici trois étapes pour évaluer le problème du point de vue de la programmation dynamique:

  1. Définition de récurrence: maxLength (i) == 1 + maxLength (j) où 0 <j <i et array [i]> array [j]
  2. Limite du paramètre de récurrence: il peut y avoir 0 à i - 1 sous-séquences passées en paramètre
  3. Ordre d'évaluation: comme elle augmente la sous-séquence, elle doit être évaluée de 0 à n

Si nous prenons comme exemple une séquence {0, 8, 2, 3, 7, 9}, à l'index:

  • [0] nous obtiendrons la sous-séquence {0} comme cas de base
  • [1] nous avons 1 nouvelle sous-séquence {0, 8}
  • [2] essayant d'évaluer deux nouvelles séquences {0, 8, 2} et {0, 2} en ajoutant un élément à l'index 2 aux sous-séquences existantes - une seule est valide, donc en ajoutant la troisième séquence possible {0, 2} seulement à la liste des paramètres ...

Voici le code C ++ 11 fonctionnel:

#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;
}
Iuri Covalisin
la source
Je pense que la définition de la récurrence devrait être maxLength (i) = 1 + max (maxLength (j)) pour 0 <j <i et array [i]> array [j] plutôt que sans max ().
Slothworks
1

Voici une implémentation Scala de l'algorithme 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)))
  }
}
lcn
la source
1

Voici une autre implémentation JAVA O (n ^ 2). Aucune récursivité / mémorisation pour générer la sous-séquence réelle. Juste un tableau de chaînes qui stocke le LIS réel à chaque étape et un tableau pour stocker la longueur du LIS pour chaque élément. C'est sacrément facile. Regarde:

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

Code en action: http://ideone.com/sBiOQx

bholagabbar
la source
0

Cela peut être résolu dans O (n ^ 2) à l'aide de la programmation dynamique. Le code Python pour le même serait comme: -

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)

Pour l'entrée:5 19 5 81 50 28 29 1 83 23

la sortie serait:[1, 2, 1, 3, 3, 3, 4, 1, 5, 3] 5

Le list_index de la liste de sortie est le list_index de la liste d'entrée. La valeur à un list_index donné dans la liste de sortie indique la plus longue longueur de sous-séquence croissante pour ce list_index.

Barun Sharma
la source
0

voici l'implémentation 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);
    }    
}
fatih tekin
la source
0

Il s'agit d'une implémentation Java en O (n ^ 2). Je n'ai tout simplement pas utilisé la recherche binaire pour trouver le plus petit élément de S, qui est> = que X. J'ai juste utilisé une boucle for. L'utilisation de la recherche binaire rendrait la complexité à 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));

}
Shashank Agarwal
la source
0

extraire le code en java pour la plus longue sous-séquence croissante avec les éléments du tableau

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();
    }
}
jayant singh
la source
0

Cela peut être résolu dans O (n ^ 2) en utilisant la programmation dynamique.

Traitez les éléments d'entrée dans l'ordre et conservez une liste de tuples pour chaque élément. Chaque tuple (A, B), pour l'élément i désigne, A = longueur de la sous-séquence croissante la plus longue se terminant en i et B = indice du prédécesseur de la liste [i] dans la sous-séquence croissante la plus longue se terminant en la liste [i ].

À partir de l'élément 1, la liste des tuple pour l'élément 1 sera [(1,0)] pour l'élément i, parcourez la liste 0..i et trouvez la liste d'éléments [k] telle que la liste [k] <liste [i] , la valeur de A pour l'élément i, Ai sera Ak + 1 et Bi sera k. S'il existe plusieurs éléments de ce type, ajoutez-les à la liste des tuples pour l'élément i.

À la fin, trouvez tous les éléments avec une valeur maximale de A (longueur de LIS se terminant à l'élément) et revenez en arrière en utilisant les tuples pour obtenir la liste.

J'ai partagé le code pour le même à http://www.edufyme.com/code/?id=66f041e16a60928b05a7e228a89c3799

Somil Bhandari
la source
3
Vous devez inclure le code dans votre réponse car les liens peuvent se rompre.
NathanOliver
0

Implémentation Java 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]+" ");
        }
    }
Mostafizar
la source
0
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)

même s'il existe un moyen de résoudre ce problème en temps O (nlogn) (cela résout en temps O (n ^ 2)), mais cela donne néanmoins l'approche de programmation dynamique qui est également bonne.

ravi tanwar
la source
0

Voici ma solution Leetcode en utilisant la recherche binaire: ->

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)
Abhinav Vajpeyi
la source
0

Solution LIS la plus simple en C ++ avec complexité temporelle 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;
}

SORTIE:
4

Ashish kumar
la source
0

Conséquence croissante la plus longue (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+" ");
        }

    }
}
Atique Reza
la source
0

J'ai implémenté LIS en java en utilisant la programmation dynamique et la mémorisation. Avec le code, j'ai fait un calcul de complexité, c'est-à-dire pourquoi c'est O (n Log (base2) n). Comme je pense que les explications théoriques ou logiques sont bonnes mais la démonstration pratique est toujours meilleure pour la compréhension.

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;

    }
}

Pendant que je courais le code ci-dessus -

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

atul sachan
la source
Donne une mauvaise réponse pour la saisie: {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
ahadcse
0

L'approche O (NLog (N)) pour trouver la sous-séquence croissante la plus longue
Maintenons un tableau où le ième élément est le plus petit nombre possible avec lequel une sous-séquence de taille ai peut se terminer.

J'évite volontairement d'autres détails car la réponse la plus votée l'explique déjà, mais cette technique conduit finalement à une implémentation soignée utilisant la structure de données définie (au moins en c ++).

Voici l'implémentation en c ++ (en supposant qu'une augmentation stricte de la taille de la sous-séquence la plus longue est requise)

#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;
}
Mayank
la source