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 subsequence is {63, 55, 46} 
Input: arr[] = {50, 3, 10, 7, 40, 80} 
Output: 3 
Explanation: The longest decreasing subsequence is {50, 10, 7} 

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

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.
?>

Javascript

<script>
// Javascript program to find the
// length of the longest
// decreasing subsequence

    // Function that returns the
// length of the longest
// decreasing subsequence
    function lds(arr,n)
    {
        let lds = new Array(n);
    let 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
    let arr=[15, 27, 14, 38,
                  63, 55, 46, 65, 85 ];

    let n = arr.length;
    document.write("Length of LDS is " +
                             lds(arr, n));


    // This code is contributed by rag2127
</script>

Output :

Length of LDS is 3

Time Complexity: O(n²) 
Auxiliary Space: O(n)
Related Article: https://www.geeksforgeeks.org/longest-increasing-subsequence/