Longest Decreasing Subsequence

Given an array of N integers, find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in strictly decreasing order.

Examples :

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}

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The problem can be solved using Dynamic Programming

Optimal Substructure:

Let arr[0..n-1] be the input array and lds[i] be the length of the LDS ending at index i such that arr[i] is the last element of the LDS.
Then, lds[i] can be recursively written as:

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

To find the LDS for a given array, we need to return max(lds[i]) where n > i > 0.

C++

// CPP program to find the length of the 
// longest decreasing subsequence 
#include <bits/stdc++.h> 
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 [tabby title="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. 

PHP

<?php 
// PHP program to find the  
// length of the longest  
// decreasing subsequence 
  
  
// Function that returns the  
// length of the longest  
// decreasing subsequence 
function lds($arr, $n) 
{ 
    $lds = array(); 
    $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] and 
                $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 
$arr = array(15, 27, 14, 38, 63, 
             55, 46, 65, 85); 
$n = count($arr); 
echo "Length of LDS is " ,  
            lds($arr, $n); 
  
// This code is contributed by anuj_67. 
?> 