Given N elements, write a program that prints the length of the longest increasing consecutive subsequence.
Examples:
Input : a[] = {3, 10, 3, 11, 4, 5, 6, 7, 8, 12}
Output : 6
Explanation: 3, 4, 5, 6, 7, 8 is the longest increasing subsequence whose adjacent element differs by one.Input : a[] = {6, 7, 8, 3, 4, 5, 9, 10}
Output : 5
Explanation: 6, 7, 8, 9, 10 is the longest increasing subsequence
Naive Approach: For every element, find the length of the subsequence starting from that particular element. Print the longest length of the subsequence thus formed:
#include <bits/stdc++.h> using namespace std;
int LongestSubsequence( int a[], int n)
{ int ans = 0;
// Traverse every element to check if any
// increasing subsequence starts from this index
for ( int i=0; i<n; i++)
{
// Initialize cnt variable as 1, which defines
// the current length of the increasing subsequence
int cnt = 1;
for ( int j=i+1; j<n; j++)
if (a[j] == (a[i]+cnt)) cnt++;
// Update the answer if the current length is
// greater than already found length
ans = max(ans, cnt);
}
return ans;
} int main()
{ int a[] = { 3, 10, 3, 11, 4, 5, 6, 7, 8, 12 };
int n = sizeof (a) / sizeof (a[0]);
cout << LongestSubsequence(a, n);
return 0;
} |
import java.util.Scanner;
public class Main {
public static int LongestSubsequence( int a[], int n)
{
int ans = 0 ;
// Traverse every element to check if any
// increasing subsequence starts from this index
for ( int i= 0 ; i<n; i++)
{
// Initialize cnt variable as 1, which defines
// the current length of the increasing subsequence
int cnt = 1 ;
for ( int j=i+ 1 ; j<n; j++)
if (a[j] == (a[i]+cnt)) cnt++;
// Update the answer if the current length is
// greater than already found length
if (cnt > ans)
ans = cnt;
}
return ans;
}
public static void main(String[] args) {
int [] a = { 3 , 10 , 3 , 11 , 4 , 5 , 6 , 7 , 8 , 12 };
int n = a.length;
System.out.println(LongestSubsequence(a, n));
}
} // This code contributed by Ajax |
def longest_subsequence(a, n):
ans = 0
# Traverse every element to check if any
# increasing subsequence starts from this index
for i in range (n):
# Initialize cnt variable as 1, which defines
# the current length of the increasing subsequence
cnt = 1
for j in range (i + 1 , n):
if a[j] = = (a[i] + cnt):
cnt + = 1
# Update the answer if the current length is
# greater than the already found length
ans = max (ans, cnt)
return ans
if __name__ = = "__main__" :
a = [ 3 , 10 , 3 , 11 , 4 , 5 , 6 , 7 , 8 , 12 ]
n = len (a)
print (longest_subsequence(a, n))
|
using System;
class GFG
{ static int LongestSubsequence( int [] a, int n)
{
int ans = 0;
// Traverse every element to check if any
// increasing subsequence starts from this index
for ( int i = 0; i < n; i++)
{
// Initialize cnt variable as 1, which defines
// current length of the increasing subsequence
int cnt = 1;
for ( int j = i + 1; j < n; j++)
{
if (a[j] == (a[i] + cnt))
{
cnt++;
}
// Update the answer if the current length is
// greater than the already found length
ans = Math.Max(ans, cnt);
}
}
return ans;
}
static void Main()
{
int [] a = { 3, 10, 3, 11, 4, 5, 6, 7, 8, 12 };
int n = a.Length;
Console.WriteLine(LongestSubsequence(a, n));
}
} |
function LongestSubsequence(a, n)
{ let ans = 0;
// Traverse every element to check if any
// increasing subsequence starts from this index
for (let i=0; i<n; i++)
{
// Initialize cnt variable as 1, which defines
// the current length of the increasing subsequence
let cnt = 1;
for (let j=i+1; j<n; j++)
if (a[j] == (a[i]+cnt)) cnt++;
// Update the answer if the current length is
// greater than already found length
ans = Math.max(ans, cnt);
}
return ans;
} let a = [ 3, 10, 3, 11, 4, 5, 6, 7, 8, 12 ]; let n = a.length; console.log(LongestSubsequence(a, n)); |
6
Time Complexity: O(N2)
Auxiliary Space: O(1)
Dynamic Programming Approach: Let DP[i] store the length of the longest subsequence which ends with A[i]. For every A[i], if A[i]-1 is present in the array before i-th index, then A[i] will add to the increasing subsequence which has A[i]-1. Hence, DP[i] = DP[ index(A[i]-1) ] + 1. If A[i]-1 is not present in the array before i-th index, then DP[i]=1 since the A[i] element forms a subsequence which starts with A[i]. Hence, the relation for DP[i] is:
If A[i]-1 is present before i-th index:
- DP[i] = DP[ index(A[i]-1) ] + 1
else:
- DP[i] = 1
Given below is the illustration of the above approach:
// CPP program to find length of the // longest increasing subsequence // whose adjacent element differ by 1 #include <bits/stdc++.h> using namespace std;
// function that returns the length of the // longest increasing subsequence // whose adjacent element differ by 1 int longestSubsequence( int a[], int n)
{ // stores the index of elements
unordered_map< int , int > mp;
// stores the length of the longest
// subsequence that ends with a[i]
int dp[n];
memset (dp, 0, sizeof (dp));
int maximum = INT_MIN;
// iterate for all element
for ( int i = 0; i < n; i++) {
// if a[i]-1 is present before i-th index
if (mp.find(a[i] - 1) != mp.end()) {
// last index of a[i]-1
int lastIndex = mp[a[i] - 1] - 1;
// relation
dp[i] = 1 + dp[lastIndex];
}
else
dp[i] = 1;
// stores the index as 1-index as we need to
// check for occurrence, hence 0-th index
// will not be possible to check
mp[a[i]] = i + 1;
// stores the longest length
maximum = max(maximum, dp[i]);
}
return maximum;
} // Driver Code int main()
{ int a[] = { 4, 3, 10, 3, 11, 4, 5, 6, 7, 8, 12 };
int n = sizeof (a) / sizeof (a[0]);
cout << longestSubsequence(a, n);
return 0;
} |
// Java program to find length of the // longest increasing subsequence // whose adjacent element differ by 1 import java.util.*;
class lics {
static int LongIncrConseqSubseq( int arr[], int n)
{
// create hashmap to save latest consequent
// number as "key" and its length as "value"
HashMap<Integer, Integer> map = new HashMap<>();
// put first element as "key" and its length as "value"
map.put(arr[ 0 ], 1 );
for ( int i = 1 ; i < n; i++) {
// check if last consequent of arr[i] exist or not
if (map.containsKey(arr[i] - 1 )) {
// put the updated consequent number
// and increment its value(length)
map.put(arr[i], map.get(arr[i] - 1 ) + 1 );
// remove the last consequent number
map.remove(arr[i] - 1 );
}
// if there is no last consequent of
// arr[i] then put arr[i]
else {
map.put(arr[i], 1 );
}
}
return Collections.max(map.values());
}
// driver code
public static void main(String args[])
{
// Take input from user
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int arr[] = new int [n];
for ( int i = 0 ; i < n; i++)
arr[i] = sc.nextInt();
System.out.println(LongIncrConseqSubseq(arr, n));
}
} // This code is contributed by CrappyDoctor |
# python program to find length of the # longest increasing subsequence # whose adjacent element differ by 1 from collections import defaultdict
import sys
# function that returns the length of the # longest increasing subsequence # whose adjacent element differ by 1 def longestSubsequence(a, n):
mp = defaultdict( lambda : 0 )
# stores the length of the longest
# subsequence that ends with a[i]
dp = [ 0 for i in range (n)]
maximum = - sys.maxsize
# iterate for all element
for i in range (n):
# if a[i]-1 is present before i-th index
if a[i] - 1 in mp:
# last index of a[i]-1
lastIndex = mp[a[i] - 1 ] - 1
# relation
dp[i] = 1 + dp[lastIndex]
else :
dp[i] = 1
# stores the index as 1-index as we need to
# check for occurrence, hence 0-th index
# will not be possible to check
mp[a[i]] = i + 1
# stores the longest length
maximum = max (maximum, dp[i])
return maximum
# Driver Code a = [ 3 , 10 , 3 , 11 , 4 , 5 , 6 , 7 , 8 , 12 ]
n = len (a)
print (longestSubsequence(a, n))
# This code is contributed by Shrikant13 |
// C# program to find length of the // longest increasing subsequence // whose adjacent element differ by 1 using System;
using System.Collections.Generic;
class GFG{
static int longIncrConseqSubseq( int []arr,
int n)
{ // Create hashmap to save
// latest consequent number
// as "key" and its length
// as "value"
Dictionary< int ,
int > map = new Dictionary< int ,
int >();
// Put first element as "key"
// and its length as "value"
map.Add(arr[0], 1);
for ( int i = 1; i < n; i++)
{
// Check if last consequent
// of arr[i] exist or not
if (map.ContainsKey(arr[i] - 1))
{
// put the updated consequent number
// and increment its value(length)
map.Add(arr[i], map[arr[i] - 1] + 1);
// Remove the last consequent number
map.Remove(arr[i] - 1);
}
// If there is no last consequent of
// arr[i] then put arr[i]
else
{
if (!map.ContainsKey(arr[i]))
map.Add(arr[i], 1);
}
}
int max = int .MinValue;
foreach (KeyValuePair< int ,
int > entry in map)
{
if (entry.Value > max)
{
max = entry.Value;
}
}
return max;
} // Driver code public static void Main(String []args)
{ // Take input from user
int []arr = {3, 10, 3, 11,
4, 5, 6, 7, 8, 12};
int n = arr.Length;
Console.WriteLine(longIncrConseqSubseq(arr, n));
} } // This code is contributed by gauravrajput1 |
<script> // JavaScript program to find length of the // longest increasing subsequence // whose adjacent element differ by 1 // function that returns the length of the // longest increasing subsequence // whose adjacent element differ by 1 function longestSubsequence(a, n)
{ // stores the index of elements
var mp = new Map();
// stores the length of the longest
// subsequence that ends with a[i]
var dp = Array(n).fill(0);
var maximum = -1000000000;
// iterate for all element
for ( var i = 0; i < n; i++) {
// if a[i]-1 is present before i-th index
if (mp.has(a[i] - 1)) {
// last index of a[i]-1
var lastIndex = mp.get(a[i] - 1) - 1;
// relation
dp[i] = 1 + dp[lastIndex];
}
else
dp[i] = 1;
// stores the index as 1-index as we need to
// check for occurrence, hence 0-th index
// will not be possible to check
mp.set(a[i], i + 1);
// stores the longest length
maximum = Math.max(maximum, dp[i]);
}
return maximum;
} // Driver Code var a = [3, 10, 3, 11, 4, 5, 6, 7, 8, 12];
var n = a.length;
document.write( longestSubsequence(a, n)); </script> |
6
Complexity Analysis:
- Time Complexity: O(N), as we are using a loop to traverse N times.
- Auxiliary Space: O(N), as we are using extra space for dp and map m.