Related Articles
Longest increasing sequence by the boundary elements of an Array
• Difficulty Level : Medium
• Last Updated : 05 May, 2021

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

 `// C++ Program to print the``// longest increasing``// subsequence from the``// boundary elements of an array` `#include ``using` `namespace` `std;` `// Function to return the length of``// Longest Increasing subsequence``int` `longestSequence(``int` `n, ``int` `arr[])``{` `    ``// Set pointers at``    ``// both ends``    ``int` `l = 0, r = n - 1;` `    ``// Stores the recent``    ``// value added to the``    ``// subsequence``    ``int` `prev = INT_MIN;` `    ``// Stores the length of``    ``// the subsequence``    ``int` `ans = 0;` `    ``while` `(l <= r) {` `        ``// Check if both elements``        ``// can be added to the``        ``// subsequence``        ``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;``            ``}``        ``}` `        ``// Check if the element``        ``// on the left can be``        ``// added to the``        ``// subsequence only``        ``else` `if` `(arr[l] > prev) {``            ``ans += 1;``            ``prev = arr[l];``            ``l += 1;``        ``}` `        ``// Check if the element``        ``// on the right can be``        ``// added to the``        ``// subsequence only``        ``else` `if` `(arr[r] > prev) {``            ``ans += 1;``            ``prev = arr[r];``            ``r -= 1;``        ``}` `        ``// If none of the values``        ``// can be added to the``        ``// subsequence``        ``else` `{``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 5, 1, 4, 2 };` `    ``// Length of array``    ``int` `n = ``sizeof``(arr)``            ``/ ``sizeof``(arr);` `    ``cout << longestSequence(n, arr);` `    ``return` `0;``}`

## Java

 `// Java program to print the longest``// increasing subsequence from the``// boundary elements of an array``import` `java.util.*;` `class` `GFG{` `// Function to return the length of``// Longest Increasing subsequence``static` `int` `longestSequence(``int` `n, ``int` `arr[])``{``    ` `    ``// Set pointers at``    ``// both ends``    ``int` `l = ``0``, r = n - ``1``;` `    ``// Stores the recent``    ``// value added to the``    ``// subsequence``    ``int` `prev = Integer.MIN_VALUE;` `    ``// Stores the length of``    ``// the subsequence``    ``int` `ans = ``0``;` `    ``while` `(l <= r)``    ``{``        ` `        ``// Check if both elements``        ``// can be added to the``        ``// subsequence``        ``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``;``            ``}``        ``}` `        ``// Check if the element on the``        ``// left can be added to the``        ``// subsequence only``        ``else` `if` `(arr[l] > prev)``        ``{``            ``ans += ``1``;``            ``prev = arr[l];``            ``l += ``1``;``        ``}` `        ``// Check if the element on the``        ``// right can be added to the``        ``// subsequence only``        ``else` `if` `(arr[r] > prev)``        ``{``            ``ans += ``1``;``            ``prev = arr[r];``            ``r -= ``1``;``        ``}` `        ``// If none of the values``        ``// can be added to the``        ``// subsequence``        ``else``        ``{``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``3``, ``5``, ``1``, ``4``, ``2` `};` `    ``// Length of array``    ``int` `n = arr.length;` `    ``System.out.print(longestSequence(n, arr));``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to print the``# longest increasing subsequence``# from the boundary elements``# of an array``import` `sys` `# Function to return the length of``# Longest Increasing subsequence``def` `longestSequence(n, arr):``    ` `    ``# Set pointers at``    ``# both ends``    ``l ``=` `0``    ``r ``=` `n ``-` `1``    ` `    ``# Stores the recent value``    ``# added to the subsequence``    ``prev ``=` `-``sys.maxsize ``-` `1``    ` `    ``# Stores the length of``    ``# the subsequence``    ``ans ``=` `0``    ` `    ``while` `(l <``=` `r):``        ` `        ``# Check if both elements can be``        ``# added to the subsequence``        ``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``                ` `        ``# Check if the element``        ``# on the left can be``        ``# added to the``        ``# subsequence only``        ``elif` `(arr[l] > prev):``            ``ans ``+``=` `1``            ``prev ``=` `arr[l]``            ``l ``+``=` `1``        ` `        ``# Check if the element``        ``# on the right can be``        ``# added to the``        ``# subsequence only``        ``elif` `(arr[r] > prev):``            ``ans ``+``=` `1``            ``prev ``=` `arr[r]``            ``r ``-``=` `1``        ` `        ``# If none of the values``        ``# can be added to the``        ``# subsequence``        ``else``:``            ``break``        ` `    ``return` `ans``            ` `# Driver code``arr ``=` `[ ``3``, ``5``, ``1``, ``4``, ``2` `]` `# Length of array``n ``=` `len``(arr)` `print``(longestSequence(n, arr))` `# This code is contributed by sanjoy_62`

## C#

 `// C# program to print the longest``// increasing subsequence from the``// boundary elements of an array``using` `System;` `class` `GFG{` `// Function to return the length of``// longest Increasing subsequence``static` `int` `longestSequence(``int` `n, ``int` `[]arr)``{``    ` `    ``// Set pointers at``    ``// both ends``    ``int` `l = 0, r = n - 1;` `    ``// Stores the recent value``    ``// added to the subsequence``    ``int` `prev = ``int``.MinValue;` `    ``// Stores the length of``    ``// the subsequence``    ``int` `ans = 0;` `    ``while` `(l <= r)``    ``{``        ` `        ``// Check if both elements``        ``// can be added to the``        ``// subsequence``        ``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;``            ``}``        ``}` `        ``// Check if the element on the``        ``// left can be added to the``        ``// subsequence only``        ``else` `if` `(arr[l] > prev)``        ``{``            ``ans += 1;``            ``prev = arr[l];``            ``l += 1;``        ``}` `        ``// Check if the element on the``        ``// right can be added to the``        ``// subsequence only``        ``else` `if` `(arr[r] > prev)``        ``{``            ``ans += 1;``            ``prev = arr[r];``            ``r -= 1;``        ``}` `        ``// If none of the values``        ``// can be added to the``        ``// subsequence``        ``else``        ``{``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 3, 5, 1, 4, 2 };` `    ``// Length of array``    ``int` `n = arr.Length;` `    ``Console.Write(longestSequence(n, arr));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 `   `
Output:

`4`

Time 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.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up