最长递减子序列

给定一个由N个整数组成的数组，请找到给定序列的最长子序列的长度，以使该子序列的所有元素均按严格降序排序。

例子 ：

Input: arr[] = [15, 27, 14, 38, 63, 55, 46, 65, 85]
Output: 3
Explanation: The longest decreasing sub sequence is {63, 55, 46}

Input: arr[] = {50, 3, 10, 7, 40, 80}
Output: 3
Explanation: The longest decreasing subsequence is {50, 10, 7}

可以使用动态编程解决问题

最佳子结构：

假设arr [0..n-1]是输入数组，而lds [i]是LDS的长度，索引的结尾是i，这样arr [i]是LDS的最后一个元素。
然后，可以将lds [i]递归编写为：

lds[i] = 1 + max( lds[j] ) where i > j > 0 and arr[j] > arr[i] or
lds[i] = 1, if no such j exists.

为了找到给定数组的LDS，我们需要返回max(lds [i]) ，其中n> i> 0。

C++

// CPP program to find the length of the
// longest decreasing subsequence
#include 
using namespace std;
  
// Function that returns the length
// of the longest decreasing subsequence
int lds(int arr[], int n)
{
    int lds[n];
    int i, j, max = 0;
  
    // Initialize LDS with 1 for all index
    // The minimum LDS starting with any
    // element is always 1
    for (i = 0; i < n; i++)
        lds[i] = 1;
  
    // Compute LDS from every index
    // in bottom up manner
    for (i = 1; i < n; i++)
        for (j = 0; j < i; j++)
            if (arr[i] < arr[j] && lds[i] < lds[j] + 1)
                lds[i] = lds[j] + 1;
  
    // Select the maximum 
    // of all the LDS values
    for (i = 0; i < n; i++)
        if (max < lds[i])
            max = lds[i];
  
    // returns the length of the LDS
    return max;
}
// Driver Code
int main()
{
    int arr[] = { 15, 27, 14, 38, 63, 55, 46, 65, 85 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Length of LDS is " << lds(arr, n);
    return 0;
}

Java

// Java program to find the 
// length of the longest 
// decreasing subsequence
import java.io.*;
  
class GFG 
{
  
// Function that returns the 
// length of the longest 
// decreasing subsequence
static int lds(int arr[], int n)
{
    int lds[] = new int[n];
    int i, j, max = 0;
  
    // Initialize LDS with 1 
    // for all index. The minimum 
    // LDS starting with any
    // element is always 1
    for (i = 0; i < n; i++)
        lds[i] = 1;
  
    // Compute LDS from every 
    // index in bottom up manner
    for (i = 1; i < n; i++)
        for (j = 0; j < i; j++)
            if (arr[i] < arr[j] && 
                         lds[i] < lds[j] + 1)
                lds[i] = lds[j] + 1;
  
    // Select the maximum 
    // of all the LDS values
    for (i = 0; i < n; i++)
        if (max < lds[i])
            max = lds[i];
  
    // returns the length
    // of the LDS
    return max;
}
// Driver Code
public static void main (String[] args)
{
    int arr[] = { 15, 27, 14, 38, 
                  63, 55, 46, 65, 85 };
    int n = arr.length;
    System.out.print("Length of LDS is " + 
                             lds(arr, n));
}
}
  
// This code is contributed by anuj_67.

Python 3

# Python 3 program to find the length of 
# the longest decreasing subsequence
  
# Function that returns the length
# of the longest decreasing subsequence
def lds(arr, n):
  
    lds = [0] * n
    max = 0
  
    # Initialize LDS with 1 for all index
    # The minimum LDS starting with any
    # element is always 1
    for i in range(n):
        lds[i] = 1
  
    # Compute LDS from every index
    # in bottom up manner
    for i in range(1, n):
        for j in range(i):
            if (arr[i] < arr[j] and 
                lds[i] < lds[j] + 1):
                lds[i] = lds[j] + 1
  
    # Select the maximum 
    # of all the LDS values
    for i in range(n):
        if (max < lds[i]):
            max = lds[i]
  
    # returns the length of the LDS
    return max
  
# Driver Code
if __name__ == "__main__":
      
    arr = [ 15, 27, 14, 38, 
            63, 55, 46, 65, 85 ]
    n = len(arr)
    print("Length of LDS is", lds(arr, n))
  
# This code is contributed by ita_c

C#

// C# program to find the 
// length of the longest 
// decreasing subsequence
using System;
  
class GFG 
{
  
// Function that returns the 
// length of the longest 
// decreasing subsequence
static int lds(int []arr, int n)
{
    int []lds = new int[n];
    int i, j, max = 0;
  
    // Initialize LDS with 1 
    // for all index. The minimum 
    // LDS starting with any
    // element is always 1
    for (i = 0; i < n; i++)
        lds[i] = 1;
  
    // Compute LDS from every 
    // index in bottom up manner
    for (i = 1; i < n; i++)
        for (j = 0; j < i; j++)
            if (arr[i] < arr[j] && 
                        lds[i] < lds[j] + 1)
                lds[i] = lds[j] + 1;
  
    // Select the maximum 
    // of all the LDS values
    for (i = 0; i < n; i++)
        if (max < lds[i])
            max = lds[i];
  
    // returns the length
    // of the LDS
    return max;
}
// Driver Code
public static void Main ()
{
    int []arr = { 15, 27, 14, 38, 
                63, 55, 46, 65, 85 };
    int n = arr.Length;
    Console.Write("Length of LDS is " + 
                          lds(arr, n));
}
}
  
// This code is contributed by anuj_67.

输出 ：

Length of LDS is 3

时间复杂度：O(n ² )
辅助空间：O(n)

相关文章：https://www.geeksforgeeks.org/longest-increasing-subsequence/