Related Articles

# Longest permutation subsequence in a given array

• Last Updated : 24 May, 2021

Given an array arr containing N elements, find the length of the longest subsequence such that it is a valid permutation of a particular length. If no such permutation sequence exists then print 0.
Examples:

Input: arr[] = {3, 2, 1, 6, 5}
Output:
Explanation:
Longest permutation subsequence will be [3, 2, 1].
Input: arr[]= {2, 3, 4, 5}
Output:
Explanation:
No valid permutation subsequence present as element 1 is missing.

Approach: The above-mentioned problem is on permutation subsequence so the order of the array elements is irrelevant, only what matter is the frequency of each element. If array is of length N then the maximum possible length for the permutation sequence is N and minimum possible length is 0. If the subsequence of length L is a valid permutation then all elements from 1 to L should be present

1. Count the frequency of the elements in the range [1, N] from the array
2. Iterate through all elements from 1 to N in the array and count the iterations till a 0 frequency is observed. If the frequency of an element is ‘0’, return the current count of iterations as the required length.

Below is the implementation of the above approach:

## C++

 `// C++ Program to find length of``// Longest Permutaion Subsequence``// in a given array` `#include ``using` `namespace` `std;` `// Function to find the``// longest permutation subsequence``int` `longestPermutation(``int` `a[], ``int` `n)``{` `    ``// Map data structure to``    ``// count the frequency of each element``    ``map<``int``, ``int``> freq;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``freq[a[i]]++;``    ``}` `    ``int` `len = 0;` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// If frequency of element is 0,``        ``// then we can not move forward``        ``// as every element should be present``        ``if` `(freq[i] == 0) {``            ``break``;``        ``}` `        ``// Increasing the length by one``        ``len++;``    ``}` `    ``return` `len;``}` `// Driver Code``int` `main()``{` `    ``int` `arr[] = { 3, 2, 1, 6, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << longestPermutation(arr, n)``         ``<< ``"\n"``;` `    ``return` `0;``}`

## Java

 `// Java Program to find length of``// Longest Permutaion Subsequence``// in a given array``import` `java.util.*;` `class` `GFG{`` ` `// Function to find the``// longest permutation subsequence``static` `int` `longestPermutation(``int` `arr[], ``int` `n)``{`` ` `    ``// Map data structure to``    ``// count the frequency of each element``    ``HashMap freq = ``new` `HashMap();`` ` `    ``for` `(``int` `i = ``0``; i < n; i++) {`` ` `        ``if``(freq.containsKey(arr[i])){``            ``freq.put(arr[i], freq.get(arr[i])+``1``);``        ``}``else``{``            ``freq.put(arr[i], ``1``);``        ``}``    ``}`` ` `    ``int` `len = ``0``;`` ` `    ``for` `(``int` `i = ``1``; i <= n; i++) {`` ` `        ``// If frequency of element is 0,``        ``// then we can not move forward``        ``// as every element should be present``        ``if` `(!freq.containsKey(i)) {``            ``break``;``        ``}`` ` `        ``// Increasing the length by one``        ``len++;``    ``}`` ` `    ``return` `len;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{`` ` `    ``int` `arr[] = { ``3``, ``2``, ``1``, ``6``, ``5` `};``    ``int` `n = arr.length;`` ` `    ``System.out.print(longestPermutation(arr, n));`` ` `}``}` `// This code is contributed by Rajput-Ji`

## C#

 `// C# Program to find length of``// longest Permutaion Subsequence``// in a given array` `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `// Function to find the``// longest permutation subsequence``static` `int` `longestPermutation(``int` `[]arr, ``int` `n)``{` `    ``// Map data structure to``    ``// count the frequency of each element``    ``Dictionary<``int``,``int``> freq = ``new` `Dictionary<``int``,``int``>();` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if``(freq.ContainsKey(arr[i])){``            ``freq[arr[i]] = freq[arr[i]] + 1;``        ``}``else``{``            ``freq.Add(arr[i], 1);``        ``}``    ``}` `    ``int` `len = 0;` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// If frequency of element is 0,``        ``// then we can not move forward``        ``// as every element should be present``        ``if` `(!freq.ContainsKey(i)) {``            ``break``;``        ``}` `        ``// Increasing the length by one``        ``len++;``    ``}` `    ``return` `len;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{` `    ``int` `[]arr = { 3, 2, 1, 6, 5 };``    ``int` `n = arr.Length;` `    ``Console.Write(longestPermutation(arr, n));` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Program to find length of``# Longest Permutaion Subsequence``# in a given array``from` `collections ``import` `defaultdict` `# Function to find the``# longest permutation subsequence``def` `longestPermutation(a, n):`` ` `    ``# Map data structure to``    ``# count the frequency of each element``    ``freq ``=` `defaultdict(``int``)`` ` `    ``for` `i ``in` `range``( n ):`` ` `        ``freq[a[i]] ``+``=` `1`` ` `    ``length ``=` `0`` ` `    ``for` `i ``in` `range``(``1` `, n ``+` `1``):`` ` `        ``# If frequency of element is 0,``        ``# then we can not move forward``        ``# as every element should be present``        ``if` `(freq[i] ``=``=` `0``):``            ``break`` ` `        ``# Increasing the length by one``        ``length ``+``=` `1``        ` `    ``return` `length`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:`` ` `    ``arr ``=` `[ ``3``, ``2``, ``1``, ``6``, ``5` `]``    ``n ``=` `len``(arr)`` ` `    ``print``(longestPermutation(arr, n))` `# This code is contributed by chitranayal`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N)
Auxiliary Space Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up