打印最长连续子序列

给定 n 个元素，编写一个程序，打印最长的递增子序列，其相邻元素差为 1。
例子：

Input : a[] = {3, 10, 3, 11, 4, 5, 6, 7, 8, 12} 
Output : 3 4 5 6 7 8 
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 : 6 7 8 9 10 
Explanation: 6, 7, 8, 9, 10 is the longest increasing subsequence 

我们已经讨论了如何找到最长递增连续子序列的长度。为了打印子序列，我们存储最后一个元素的索引。然后我们打印以最后一个元素结尾的连续元素。
下面给出了上述方法的实现：

C++

// CPP program to find length of the
// longest increasing subsequence
// whose adjacent element differ by 1
#include 
using namespace std;
 
// function that returns the length of the
// longest increasing subsequence
// whose adjacent element differ by 1
void longestSubsequence(int a[], int n)
{
    // stores the index of elements
    unordered_map 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
    int index = -1;
    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
        if (maximum < dp[i]) {
            maximum = dp[i];
            index = i;
        }
    }
 
    // We know last element of sequence is
    // a[index]. We also know that length
    // of subsequence is "maximum". So We
    // print these many consecutive elements
    // starting from "a[index] - maximum + 1"
    // to a[index].
    for (int curr = a[index] - maximum + 1;
         curr <= a[index]; curr++)
        cout << curr << " ";
}
 
// Driver Code
int main()
{
    int a[] = { 3, 10, 3, 11, 4, 5, 6, 7, 8, 12 };
    int n = sizeof(a) / sizeof(a[0]);
    longestSubsequence(a, n);
    return 0;
}

Java

// Java program to find length of the
// longest increasing subsequence
// whose adjacent element differ by
import java.util.HashMap;
 
class GFG
{
 
    // function that returns the length of the
    // longest increasing subsequence
    // whose adjacent element differ by 1
    public static void longestSubsequence(int[] a,
                                          int n)
    {
 
        // stores the index of elements
        HashMap mp = new HashMap<>();
 
        // stores the length of the longest
        // subsequence that ends with a[i]
        int[] dp = new int[n];
 
        int maximum = Integer.MIN_VALUE;
 
        // iterate for all element
        int index = -1;
        for(int i = 0; i < n; i++)
        {
 
            // if a[i]-1 is present before i-th index
            if (mp.get(a[i] - 1) != null)
            {
 
                // last index of a[i]-1
                int 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.put(a[i], i +  1);
 
            // stores the longest length
            if (maximum < dp[i])
            {
                maximum = dp[i];
                index = i;
            }
        }
 
        // We know last element of sequence is
        // a[index]. We also know that length
        // of subsequence is "maximum". So We
        // print these many consecutive elements
        // starting from "a[index] - maximum + 1"
        // to a[index].
        for (int curr = a[index] - maximum + 1;
            curr <= a[index]; curr++)
            System.out.print(curr + " ");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] a = { 3, 10, 3, 11, 4,
                    5, 6, 7, 8, 12 };
        int n = a.length;
        longestSubsequence(a, n);
    }
}
 
// This code is contributed by sanjeev2552

Python3

# Python 3 program to find length of
# the longest increasing subsequence
# whose adjacent element differ by 1
import sys
 
# function that returns the length
# of the longest increasing subsequence
# whose adjacent element differ by 1
def longestSubsequence(a, n):
     
    # stores the index of elements
    mp = {i:0 for i in range(13)}
 
    # stores the length of the longest
    # subsequence that ends with a[i]
    dp = [0 for i in range(n)]
 
    maximum = -sys.maxsize - 1
 
    # iterate for all element
    index = -1
    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
        if (maximum < dp[i]):
            maximum = dp[i]
            index = i
 
    # We know last element of sequence is
    # a[index]. We also know that length
    # of subsequence is "maximum". So We
    # print these many consecutive elements
    # starting from "a[index] - maximum + 1"
    # to a[index].
    for curr in range(a[index] - maximum + 1,
                      a[index] + 1, 1):
        print(curr, end = " ")
 
# Driver Code
if __name__ == '__main__':
    a = [3, 10, 3, 11, 4, 5,
                6, 7, 8, 12]
    n = len(a)
    longestSubsequence(a, n)
 
# This code is contributed by
# Surendra_Gangwar

C#

// C# program to find length of the
// longest increasing subsequence
// whose adjacent element differ by
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // function that returns the length of the
    // longest increasing subsequence
    // whose adjacent element differ by 1
    static void longestSubsequence(int[] a, int n)
    {
 
        // stores the index of elements
        Dictionary mp = new Dictionary();
 
        // stores the length of the longest
        // subsequence that ends with a[i]
        int[] dp = new int[n];
 
        int maximum = -100000000;
 
        // iterate for all element
        int index = -1;
        for(int i = 0; i < n; i++)
        {
 
            // if a[i]-1 is present before i-th index
            if (mp.ContainsKey(a[i] - 1) == true)
            {
 
                // 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
            if (maximum < dp[i])
            {
                maximum = dp[i];
                index = i;
            }
        }
 
        // We know last element of sequence is
        // a[index]. We also know that length
        // of subsequence is "maximum". So We
        // print these many consecutive elements
        // starting from "a[index] - maximum + 1"
        // to a[index].
        for (int curr = a[index] - maximum + 1;
            curr <= a[index]; curr++)
            Console.Write(curr + " ");
    }
 
    // Driver Code
    static void Main()
    {
        int[] a = { 3, 10, 3, 11, 4,
                    5, 6, 7, 8, 12 };
        int n = a.Length;
        longestSubsequence(a, n);
    }
}
 
// This code is contributed by mohit kumar

Javascript

// Javascript program to find length of the
// longest increasing subsequence
// whose adjacent element differ by
     
    // 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
        let mp = new Map();
   
        // stores the length of the longest
        // subsequence that ends with a[i]
        let dp = new Array(n);
   
        let maximum = Number.MIN_VALUE;
   
        // iterate for all element
        let index = -1;
        for(let i = 0; i < n; i++)
        {
   
            // if a[i]-1 is present before i-th index
            if (mp.get(a[i] - 1) != null)
            {
   
                // last index of a[i]-1
                let 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
            if (maximum < dp[i])
            {
                maximum = dp[i];
                index = i;
            }
        }
   
        // We know last element of sequence is
        // a[index]. We also know that length
        // of subsequence is "maximum". So We
        // print these many consecutive elements
        // starting from "a[index] - maximum + 1"
        // to a[index].
        for (let curr = a[index] - maximum + 1;
            curr <= a[index]; curr++)
            document.write(curr + " ");
    }
     
    // Driver Code
    let a=[3, 10, 3, 11, 4,
                    5, 6, 7, 8, 12 ];
                     
    let n = a.length;
    longestSubsequence(a, n);
     
// This code is contributed by patel2127

输出：

3 4 5 6 7 8 

时间复杂度： O(nlogn)
辅助空间： O(n)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。