# Longest permutation subsequence in a given array

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:3

Explanation:

Longest permutation subsequence will be [3, 2, 1].

Input:arr[]= {2, 3, 4, 5}

Output:0

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

- Count the frequency of the elements in the range [1, N] from the array
- 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 <bits/stdc++.h> ` `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[0]); ` ` ` ` ` `cout << longestPermutation(arr, n) ` ` ` `<< ` `"\n"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## 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<Integer,Integer> freq = ` `new` `HashMap<Integer,Integer>(); ` ` ` ` ` `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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

**Output:**

3

**Time Complexity:** O(N)

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Find the longest subsequence of an array having LCM at most K
- Longest subsequence of even numbers in an Array
- Length of Longest Prime Subsequence in an Array
- Length of longest subsequence of Fibonacci Numbers in an Array
- Length of Longest Perfect number Subsequence in an Array
- Length of longest Powerful number subsequence in an Array
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Longest subsequence with no 0 after 1
- Longest Zig-Zag Subsequence
- Longest subsequence with a given AND value | O(N)
- Longest subsequence with a given AND value
- Longest Consecutive Subsequence
- Longest Bitonic Subsequence in O(n log n)
- Longest Increasing Odd Even Subsequence
- Longest Increasing Subsequence using BIT
- Longest subsequence whose average is less than K
- Longest Increasing Subsequence having sum value atmost K
- Longest alternative parity subsequence
- Longest Common Anagram Subsequence
- Longest subsequence having equal numbers of 0 and 1

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.