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

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 = 1Output: {5, 6}

Input: arr[] = {4, 6, 7, 8, 9, 8, 12, 14, 17, 15}, K = 2Output: {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]**.

- Search for (
- 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 <bits/stdc++.h>` `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<pair<` `int` `, ` `int` `> > dp(N, { 1, -1 });` ` ` `unordered_map<` `int` `, ` `int` `> mp;` ` ` `mp[arr[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.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;` `}` |

## 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

`<script>` `// JavaScript program to implement above approach` `// Function to find the longest subsequence` `function` `maxSubsequence(arr, K){` ` ` ` ` `let N = arr.length` ` ` ` ` `// Declaring the dp[] array and map` ` ` `let dp = ` `new` `Array(N).fill([]).map(()=>[1,-1])` ` ` `let mp = ` `new` `Map()` ` ` `mp.set(arr[0], 1)` ` ` ` ` `// Initialise variable to store` ` ` `// maximum length and last index of` ` ` `// the longest subsequence` ` ` `let maxlen = 1` ` ` `let ind = 0` ` ` ` ` `// Loop to find out the longest` ` ` `// subsequence` ` ` `for` `(let i=1;i<N;i++){` ` ` ` ` `// If arr[i]-K is present in the part` ` ` `// of array visited till now` ` ` `if` `(mp.has(arr[i] - K)== ` `true` `)` ` ` `dp[i] = [dp[mp.get(arr[i] - K) - 1][0] + 1, mp.get(arr[i] - K) - 1]` ` ` ` ` `// If arr[i]+K is present in the part` ` ` `// of array visited till now` ` ` `if` `(mp.has(arr[i] + K)){` ` ` `if` `(dp[i][0] < dp[mp.get(arr[i] + K) - 1][0] + 1){` ` ` `dp[i][0]= dp[mp.get(arr[i] + K) - 1][0] + 1` ` ` `dp[i][1] = mp.get(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.set(arr[i], i + 1)` ` ` `}` ` ` ` ` `// Declare vector to store the` ` ` `// longest subsequence` ` ` `let v =[]` ` ` ` ` `// Loop to generate the subsequence` ` ` `while` `(ind >= 0){` ` ` `v.push(arr[ind])` ` ` `ind = dp[ind][1]` ` ` `}` ` ` ` ` `v.reverse()` ` ` `return` `v` `}` `// Driver code` `let arr = [4, 6, 7, 8, 9, 8, 12, 14, 17, 15 ]` `let K = 2` `// Calling function to find` `// longest subsequence` `let longSubseq = maxSubsequence(arr, K)` `for` `(let i of longSubseq)` ` ` `document.write(i ,` `" "` `)` `document.write(` `"</br>"` `)` `// This code is contributed by shinjanpatra` `</script>` |

**Output**

4 6 8

* Time Complexity*: O(N)

*: O(N)*

**Auxiliary Space**