 Open in App
Not now

# Print longest Subsequence such that difference between adjacent elements is K

• Difficulty Level : Hard
• Last Updated : 24 Feb, 2023

Given an array arr[] of size N, and integer K. The task is to find the longest subsequence with the difference between adjacent elements as K

Examples:

Input: arr[] = { 5, 5, 5, 10, 8, 6, 12, 13 }, K = 1
Output: {5, 6}

Input: arr[] = {4, 6, 7, 8, 9, 8, 12, 14, 17, 15}, K = 2
Output: {4, 6, 8}

Approach: The task can be solved with the help of dynamic programming. Every element of the array can be considered as the last element of a subsequence. For every element, the idea is to store the length of the longest subsequence having differences between adjacent elements K and the predecessor of the current element on that subsequence. Follow the steps mentioned below to implement the approach.

• Create a map, to store the last occurrence of each element.
• Create an array of pairs dp[] to store the length of longest subsequence ending at an index and the predecessor of that index.
• Now, traverse the array arr[], and for each element arr[i]:
• Search for (arr[i] – K), (arr[i] + K) in the map.
• If they are present, then find out the subsequence with maximum length and store the length and predecessor in dp[i].
• Print the longest subsequence with help of predecessors stored in the array dp[].

Below is the implementation of the above approach.

## C++

 `// C++ program to implement above approach``#include ``using` `namespace` `std;` `// Function to find the longest subsequence``vector<``int``> maxSubsequence(vector<``int``>& arr, ``int` `K)``{``    ``int` `N = arr.size();` `    ``// Declaring the dp[] array and map``    ``vector > dp(N, { 1, -1 });``    ``unordered_map<``int``, ``int``> mp;``    ``mp[arr] = 1;` `    ``// Initialise variable to store``    ``// maximum length and last index of``    ``// the longest subsequence``    ``int` `maxlen = 1, ind = 0;` `    ``// Loop to find out the longest``    ``// subsequence``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// If arr[i]-K is present in the part``        ``// of array visited till now``        ``if` `(mp.count(arr[i] - K)) {``            ``dp[i] = { dp[mp[arr[i] - K] - 1].first + 1,``                      ``mp[arr[i] - K] - 1 };``        ``}` `        ``// If arr[i]+K is present in the part``        ``// of array visited till now``        ``if` `(mp.count(arr[i] + K)) {``            ``if` `(dp[i].first``                ``< dp[mp[arr[i] + K] - 1].first + 1) {``                ``dp[i].first``                    ``= dp[mp[arr[i] + K] - 1].first + 1;``                ``dp[i].second = mp[arr[i] + K] - 1;``            ``}``        ``}` `        ``// If maximum length increase store``        ``// the length and current index as the``        ``// last index of longest subsequence``        ``if` `(maxlen < dp[i].first) {``            ``maxlen = dp[i].first;``            ``ind = i;``        ``}``        ``mp[arr[i]] = i + 1;``    ``}` `    ``// Declare vector to store the``    ``// longest subsequence``    ``vector<``int``> v;` `    ``// Loop to generate the subsequence``    ``while` `(ind >= 0) {``        ``v.push_back(arr[ind]);``        ``ind = dp[ind].second;``    ``}``    ``reverse(v.begin(), v.end());``    ``return` `v;``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr = { 4, 6, 7, 8, 9, 8, 12,``                       ``14, 17, 15 };``    ``int` `K = 2;` `    ``// Calling function to find``    ``// longest subsequence``    ``vector<``int``> longSubseq =``        ``maxSubsequence(arr, K);``    ``for` `(``auto` `i : longSubseq)``        ``cout << i << ``" "``;``    ``cout << endl;` `    ``return` `0;``}`

## Java

 `// Java program to implement above approach``import` `java.util.*;` `class` `Main {``  ` `  ``static` `class` `Pair {``        ``public` `K key;``        ``public` `V value;` `        ``public` `Pair(K key, V value) {``            ``this``.key = key;``            ``this``.value = value;``        ``}` `        ``public` `K getKey() {``            ``return` `key;``        ``}` `        ``public` `V getValue() {``            ``return` `value;``        ``}``    ``}` `  ` `    ``// Function to find the longest subsequence``    ``public` `static` `ArrayList maxSubsequence(ArrayList arr,``                                                                       ``int` `K) {``        ``int` `N = arr.size();` `        ``// Declaring the dp[] array and map``        ``ArrayList> dp = ``new` `ArrayList>(N);``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``dp.add(``new` `Pair(``1``, -``1``));``        ``}``        ``HashMap mp = ``new` `HashMap();``        ``mp.put(arr.get(``0``), ``1``);` `        ``// Initialise variable to store``        ``// maximum length and last index of``        ``// the longest subsequence``        ``int` `maxlen = ``1``, ind = ``0``;` `        ``// Loop to find out the longest``        ``// subsequence``        ``for` `(``int` `i = ``1``; i < N; i++) {` `            ``// If arr[i]-K is present in the part``            ``// of array visited till now``            ``if` `(mp.containsKey(arr.get(i) - K)) {``                ``dp.set(i, ``new` `Pair(dp.get(mp.get(arr.get(i) - K) - ``1``).getKey() + ``1``,``                        ``mp.get(arr.get(i) - K) - ``1``));``            ``}` `            ``// If arr[i]+K is present in the part``            ``// of array visited till now``            ``if` `(mp.containsKey(arr.get(i) + K)) {``                ``if` `(dp.get(i).getKey() <``                    ``dp.get(mp.get(arr.get(i) + K) - ``1``).getKey() + ``1``) {``                    ``dp.set(i, ``new` `Pair(dp.get(mp.get(arr.get(i) + K) - ``1``).getKey() + ``1``,``                            ``mp.get(arr.get(i) + K) - ``1``));``                ``}``            ``}` `            ``// If maximum length increase store``            ``// the length and current index as the``            ``// last index of longest subsequence``            ``if` `(maxlen < dp.get(i).getKey()) {``                ``maxlen = dp.get(i).getKey();``                ``ind = i;``            ``}``            ``mp.put(arr.get(i), i + ``1``);``        ``}` `        ``// Declare vector to store the``        ``// longest subsequence``        ``ArrayList v = ``new` `ArrayList();` `        ``// Loop to generate the subsequence``        ``while` `(ind >= ``0``) {``            ``v.add(arr.get(ind));``            ``ind = dp.get(ind).getValue();``        ``}``        ``Collections.reverse(v);``        ``return` `v;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``ArrayList arr =``          ``new` `ArrayList(Arrays.asList(``4``, ``6``, ``7``, ``8``, ``9``, ``8``, ``12``, ``14``, ``17``, ``15``));``        ``int` `K = ``2``;` `        ``// Calling function to find``        ``// longest subsequence``        ``ArrayList longSubseq = maxSubsequence(arr, K);``    ``for` `(``int` `i : longSubseq)``        ``System.out.print(i + ``" "``);``    ``System.out.println();``      ` `    ``}``}`

## Python3

 `# Python program to implement above approach` `# Function to find the longest subsequence``def` `maxSubsequence(arr, K):``    ` `    ``N ``=` `len``(arr)``    ` `    ``# Declaring the dp[] array and map``    ``dp ``=` `[[``1``, ``-``1``] ``for` `i ``in` `range``(N)]``    ``mp ``=` `{}``    ``mp[arr[``0``]] ``=` `1``    ` `    ``# Initialise variable to store``    ``# maximum length and last index of``    ``# the longest subsequence``    ``maxlen ``=` `1``    ``ind ``=` `0``    ` `    ``# Loop to find out the longest``    ``# subsequence``    ``for` `i ``in` `range``(``1``,N):``        ` `        ``# If arr[i]-K is present in the part``        ``# of array visited till now``        ``if` `(arr[i] ``-` `K) ``in` `mp:``            ``dp[i] ``=`  `[dp[mp[arr[i] ``-` `K] ``-` `1``][``0``] ``+` `1``, mp[arr[i] ``-` `K] ``-` `1``]``            ` `        ``# If arr[i]+K is present in the part``        ``# of array visited till now``        ``if` `(arr[i] ``+` `K) ``in` `mp:``            ``if` `(dp[i][``0``] < dp[mp[arr[i] ``+` `K] ``-` `1``][``0``] ``+` `1``):``                ``dp[i][``0``]``=` `dp[mp[arr[i] ``+` `K] ``-` `1``][``0``] ``+` `1``                ``dp[i][``1``] ``=` `mp[arr[i] ``+` `K] ``-` `1``                ` `        ``# If maximum length increase store``        ``# the length and current index as the``        ``# last index of longest subsequence``        ``if` `(maxlen < dp[i][``0``]):``            ``maxlen ``=` `dp[i][``0``]``            ``ind ``=` `i``            ` `        ``mp[arr[i]] ``=` `i ``+` `1``        ` `    ``# Declare vector to store the``    ``# longest subsequence``    ``v ``=``[]``    ` `    ``# Loop to generate the subsequence``    ``while` `(ind >``=` `0``):``        ``v.append(arr[ind])``        ``ind ``=` `dp[ind][``1``]``        ` `    ``v.reverse()``    ``return` `v` `# Driver code``arr ``=`  `[``4``, ``6``, ``7``, ``8``, ``9``, ``8``, ``12``, ``14``, ``17``, ``15` `]``K ``=` `2` `# Calling function to find``# longest subsequence``longSubseq ``=` `maxSubsequence(arr, K)``for` `i ``in` `longSubseq:``    ``print``(i , end``=` `" "``)``print``()` `# This code is contributed by Shubham Singh`

## Javascript

 ``

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `Program``{``    ``// Function to find the longest subsequence``    ``static` `List<``int``> MaxSubsequence(List<``int``> arr, ``int` `K)``    ``{``        ``int` `N = arr.Count();` `        ``// Declaring the dp[] array and map``        ``List<(``int``, ``int``)> dp = Enumerable.Repeat((1, -1), N).ToList();``        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();``        ``mp[arr] = 1;` `        ``// Initialise variable to store``        ``// maximum length and last index of``        ``// the longest subsequence``        ``int` `maxlen = 1, ind = 0;` `        ``// Loop to find out the longest``        ``// subsequence``        ``for` `(``int` `i = 1; i < N; i++)``        ``{``            ``// If arr[i]-K is present in the part``            ``// of array visited till now``            ``if` `(mp.ContainsKey(arr[i] - K))``            ``{``                ``dp[i] = (dp[mp[arr[i] - K] - 1].Item1 + 1, mp[arr[i] - K] - 1);``            ``}` `            ``// If arr[i]+K is present in the part``            ``// of array visited till now``            ``if` `(mp.ContainsKey(arr[i] + K))``            ``{``                ``if` `(dp[i].Item1 < dp[mp[arr[i] + K] - 1].Item1 + 1)``                ``{``                    ``dp[i] = (dp[mp[arr[i] + K] - 1].Item1 + 1, mp[arr[i] + K] - 1);``                ``}``            ``}` `            ``// If maximum length increase store``            ``// the length and current index as the``            ``// last index of longest subsequence``            ``if` `(maxlen < dp[i].Item1)``            ``{``                ``maxlen = dp[i].Item1;``                ``ind = i;``            ``}``            ``mp[arr[i]] = i + 1;``        ``}` `        ``// Declare list to store the``        ``// longest subsequence``        ``List<``int``> v = ``new` `List<``int``>();` `        ``// Loop to generate the subsequence``        ``while` `(ind >= 0)``        ``{``            ``v.Add(arr[ind]);``            ``ind = dp[ind].Item2;``        ``}``        ``v.Reverse();``        ``return` `v;``    ``}` `    ``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> arr = ``new` `List<``int``>() { 4, 6, 7, 8, 9, 8, 12, 14, 17, 15 };``        ``int` `K = 2;` `        ``// Calling function to find``        ``// longest subsequence``        ``List<``int``> longSubseq = MaxSubsequence(arr, K);``        ``foreach` `(``var` `i ``in` `longSubseq)``            ``Console.Write(i + ``" "``);``        ``Console.WriteLine();``    ``}``}`

Output

`4 6 8 `

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up