数组边界元素的最长递增序列

给定长度为N且具有唯一元素的数组arr [] ，任务是从数组的任一端找到元素可以形成的最长递增子序列的长度。
例子：

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} 
 

方法：此问题可以通过两指针方法解决。在数组的第一个和最后一个索引处设置两个指针。选择当前指向的两个值中的最小值，然后检查它是否大于先前选择的值。如果是这样，请更新指针并增加LIS的长度，然后重复该过程。否则，打印获得的LIS的长度。
下面是上述方法的实现：

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[0]);
 
    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

// Javascript Program to print the
// longest increasing
// subsequence from the
// boundary elements of an array
 
// Function to return the length of
// Longest Increasing subsequence
function longestSequence(n, arr)
{
 
    // Set pointers at
    // both ends
    var l = 0, r = n - 1;
 
    // Stores the recent
    // value added to the
    // subsequence
    var prev = -1000000000;
 
    // Stores the length of
    // the subsequence
    var 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
var arr = [ 3, 5, 1, 4, 2 ];
 
// Length of array
var n = arr.length;
document.write( longestSequence(n, arr));
 
// This code is contributed by itsok.

输出：

4

时间复杂度： O(N)

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。