Longest increasing sequence by the boundary elements of an Array
Given an array arr[] of length N with unique elements, the task is to find the length of the longest increasing subsequence that can be formed by the elements from either end of the array.
Examples:
Input: arr[] = {3, 5, 1, 4, 2}
Output: 4
Explanation:
The longest sequence is: {2, 3, 4, 5}
Pick 2, Sequence is {2}, Array is {3, 5, 1, 4}
Pick 3, Sequence is {2, 3}, Array is {5, 1, 4}
Pick 4, Sequence is {2, 3, 4}, Array is {5, 1}
Pick 5, Sequence is {2, 3, 4, 5}, Array is {1}
Input: arr[] = {3, 1, 5, 2, 4}
Output: 2
The longest sequence is {3, 4}
Approach: This problem can be solved by Two Pointer Approach. Set two pointers at the first and last indices of the array. Select the minimum of the two values currently pointed and check if it is greater than the previously selected value. If so, update the pointer and increase the length of the LIS and repeat the process. Otherwise, print the length of the LIS obtained.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int longestSequence( int n, int arr[])
{
int l = 0, r = n - 1;
int prev = INT_MIN;
int ans = 0;
while (l <= r) {
if (arr[l] > prev
&& arr[r] > prev) {
if (arr[l] < arr[r]) {
ans += 1;
prev = arr[l];
l += 1;
}
else {
ans += 1;
prev = arr[r];
r -= 1;
}
}
else if (arr[l] > prev) {
ans += 1;
prev = arr[l];
l += 1;
}
else if (arr[r] > prev) {
ans += 1;
prev = arr[r];
r -= 1;
}
else {
break ;
}
}
return ans;
}
int main()
{
int arr[] = { 3, 5, 1, 4, 2 };
int n = sizeof (arr)
/ sizeof (arr[0]);
cout << longestSequence(n, arr);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int longestSequence( int n, int arr[])
{
int l = 0 , r = n - 1 ;
int prev = Integer.MIN_VALUE;
int ans = 0 ;
while (l <= r)
{
if (arr[l] > prev &&
arr[r] > prev)
{
if (arr[l] < arr[r])
{
ans += 1 ;
prev = arr[l];
l += 1 ;
}
else
{
ans += 1 ;
prev = arr[r];
r -= 1 ;
}
}
else if (arr[l] > prev)
{
ans += 1 ;
prev = arr[l];
l += 1 ;
}
else if (arr[r] > prev)
{
ans += 1 ;
prev = arr[r];
r -= 1 ;
}
else
{
break ;
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 3 , 5 , 1 , 4 , 2 };
int n = arr.length;
System.out.print(longestSequence(n, arr));
}
}
|
Python3
import sys
def longestSequence(n, arr):
l = 0
r = n - 1
prev = - sys.maxsize - 1
ans = 0
while (l < = r):
if (arr[l] > prev and
arr[r] > prev):
if (arr[l] < arr[r]):
ans + = 1
prev = arr[l]
l + = 1
else :
ans + = 1
prev = arr[r]
r - = 1
elif (arr[l] > prev):
ans + = 1
prev = arr[l]
l + = 1
elif (arr[r] > prev):
ans + = 1
prev = arr[r]
r - = 1
else :
break
return ans
arr = [ 3 , 5 , 1 , 4 , 2 ]
n = len (arr)
print (longestSequence(n, arr))
|
C#
using System;
class GFG{
static int longestSequence( int n, int []arr)
{
int l = 0, r = n - 1;
int prev = int .MinValue;
int ans = 0;
while (l <= r)
{
if (arr[l] > prev &&
arr[r] > prev)
{
if (arr[l] < arr[r])
{
ans += 1;
prev = arr[l];
l += 1;
}
else
{
ans += 1;
prev = arr[r];
r -= 1;
}
}
else if (arr[l] > prev)
{
ans += 1;
prev = arr[l];
l += 1;
}
else if (arr[r] > prev)
{
ans += 1;
prev = arr[r];
r -= 1;
}
else
{
break ;
}
}
return ans;
}
public static void Main(String[] args)
{
int []arr = { 3, 5, 1, 4, 2 };
int n = arr.Length;
Console.Write(longestSequence(n, arr));
}
}
|
Javascript
<script>
function longestSequence(n, arr)
{
var l = 0, r = n - 1;
var prev = -1000000000;
var ans = 0;
while (l <= r) {
if (arr[l] > prev
&& arr[r] > prev) {
if (arr[l] < arr[r]) {
ans += 1;
prev = arr[l];
l += 1;
}
else {
ans += 1;
prev = arr[r];
r -= 1;
}
}
else if (arr[l] > prev) {
ans += 1;
prev = arr[l];
l += 1;
}
else if (arr[r] > prev) {
ans += 1;
prev = arr[r];
r -= 1;
}
else {
break ;
}
}
return ans;
}
var arr = [ 3, 5, 1, 4, 2 ];
var n = arr.length;
document.write( longestSequence(n, arr));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Last Updated :
20 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...