# Number of sub-sequence such that it has one consecutive element with difference less than or equal to 1

Given an array **arr[]** of **N** elements. The task is to find the number of sub-sequences which have at least two consecutive elements such that absolute difference between them is **≤ 1**.

**Examples:**

Input:arr[] = {1, 6, 2, 1}

Output:6

{1, 2}, {1, 2, 1}, {2, 1}, {6, 2, 1}, {1, 1} and {1, 6, 2, 1}

are the sub-sequences that have at least one consecutive pair

with difference less than or equal to 1.

Input:arr[] = {1, 6, 2, 1, 9}

Output:12

**Naive approach:** The idea is to find all the possible sub-sequences and check if there exist sub-sequence with any consecutive pair with difference ≤1 and increase the count.

**Efficient approach:** The idea is to iterate over the given array and for each ith-element, try to find the required sub-sequence ending with ith element as its last element.

For every i, we want to use arr[i], arr[i] -1, arr[i] + 1, so we will define 2D array, **dp[][]**, where dp[i][0] will contain the number of sub sequence that do not have any consecutive pair with difference less than 1 and dp[i][1] contain the number of sub sequence having any consecutive pair with difference ≤1.

Also, we will maintain two variables **required_subsequence** and **not_required_subsdequence** to maintain the count of sub sequences which have at least one consecutive element with difference ≤1 and count of sub-sequences which do not contain any consecutive element pair with difference ≤1.

Now, considering the sub-array arr[1] …. arr[i], we will perform the following steps:

- Compute the number of sub sequences which do not have any consecutive pair with difference less than 1 but will have by adding the ith element in the sub sequence. These are basically sum of dp[arr[i] + 1][0], dp[arr[i] – 1][0] and dp[arr[i]][0].
- Total number of sub sequences have at least one consecutive pair with difference at least 1 and ending at i is equal to total sub-sequences found till i (just append arr[i] at the last) + sub sequences which turns into sub sequence have at least consecutive pair with difference less than 1 on adding arr[i].
- Total sub sequence which do not have any consecutive pair with difference less than 1 and ending at i = total sub-sequence which do not have any consecutive pair with difference less than 1 before i + 1 (just the current element as a sub sequence).
- Update required_sub-sequence, not_required_subsequence and dp[arr[i][0]] and the final answer will be required_subsequence.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `const` `int` `N = 10000; ` ` ` `// Function to return the number of subsequences ` `// which have at least one consecutive pair ` `// with difference less than or equal to 1 ` `int` `count_required_sequence(` `int` `n, ` `int` `arr[]) ` `{ ` ` ` `int` `total_required_subsequence = 0; ` ` ` `int` `total_n_required_subsequence = 0; ` ` ` `int` `dp[N][2]; ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Not required sub-sequences which ` ` ` `// turn required on adding i ` ` ` `int` `turn_required = 0; ` ` ` `for` `(` `int` `j = -1; j <= 1; j++) ` ` ` `turn_required += dp[arr[i] + j][0]; ` ` ` ` ` `// Required sub-sequence till now will be ` ` ` `// required sequence plus sub-sequence ` ` ` `// which turns required ` ` ` `int` `required_end_i = (total_required_subsequence ` ` ` `+ turn_required); ` ` ` ` ` `// Similarly for not required ` ` ` `int` `n_required_end_i = (1 + total_n_required_subsequence ` ` ` `- turn_required); ` ` ` ` ` `// Also updating total required and ` ` ` `// not required sub-sequences ` ` ` `total_required_subsequence += required_end_i; ` ` ` `total_n_required_subsequence += n_required_end_i; ` ` ` ` ` `// Also, storing values in dp ` ` ` `dp[arr[i]][1] += required_end_i; ` ` ` `dp[arr[i]][0] += n_required_end_i; ` ` ` `} ` ` ` ` ` `return` `total_required_subsequence; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 6, 2, 1, 9 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(` `int` `); ` ` ` ` ` `cout << count_required_sequence(n, arr) << ` `"\n"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implemenation of above approach ` `public` `class` `GFG ` `{ ` ` ` `static` `int` `N = ` `10000` `; ` ` ` `// Function to return the number of subsequences ` `// which have at least one consecutive pair ` `// with difference less than or equal to 1 ` `static` `int` `count_required_sequence(` `int` `n, ` `int` `arr[]) ` `{ ` ` ` `int` `total_required_subsequence = ` `0` `; ` ` ` `int` `total_n_required_subsequence = ` `0` `; ` ` ` `int` `[][]dp = ` `new` `int` `[N][` `2` `]; ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` ` ` `// Not required sub-sequences which ` ` ` `// turn required on adding i ` ` ` `int` `turn_required = ` `0` `; ` ` ` `for` `(` `int` `j = -` `1` `; j <= ` `1` `; j++) ` ` ` `turn_required += dp[arr[i] + j][` `0` `]; ` ` ` ` ` `// Required sub-sequence till now will be ` ` ` `// required sequence plus sub-sequence ` ` ` `// which turns required ` ` ` `int` `required_end_i = (total_required_subsequence ` ` ` `+ turn_required); ` ` ` ` ` `// Similarly for not required ` ` ` `int` `n_required_end_i = (` `1` `+ total_n_required_subsequence ` ` ` `- turn_required); ` ` ` ` ` `// Also updating total required and ` ` ` `// not required sub-sequences ` ` ` `total_required_subsequence += required_end_i; ` ` ` `total_n_required_subsequence += n_required_end_i; ` ` ` ` ` `// Also, storing values in dp ` ` ` `dp[arr[i]][` `1` `] += required_end_i; ` ` ` `dp[arr[i]][` `0` `] += n_required_end_i; ` ` ` `} ` ` ` ` ` `return` `total_required_subsequence; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `arr[] = { ` `1` `, ` `6` `, ` `2` `, ` `1` `, ` `9` `}; ` ` ` `int` `n = arr.length; ` ` ` ` ` `System.out.println(count_required_sequence(n, arr)); ` `} ` `} ` ` ` `// This code has been contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` `import` `numpy as np; ` ` ` `N ` `=` `10000` `; ` ` ` `# Function to return the number of subsequences ` `# which have at least one consecutive pair ` `# with difference less than or equal to 1 ` `def` `count_required_sequence(n, arr) : ` ` ` ` ` `total_required_subsequence ` `=` `0` `; ` ` ` `total_n_required_subsequence ` `=` `0` `; ` ` ` `dp ` `=` `np.zeros((N,` `2` `)); ` ` ` ` ` `for` `i ` `in` `range` `(n) : ` ` ` ` ` `# Not required sub-sequences which ` ` ` `# turn required on adding i ` ` ` `turn_required ` `=` `0` `; ` ` ` `for` `j ` `in` `range` `(` `-` `1` `, ` `2` `,` `1` `) : ` ` ` `turn_required ` `+` `=` `dp[arr[i] ` `+` `j][` `0` `]; ` ` ` ` ` `# Required sub-sequence till now will be ` ` ` `# required sequence plus sub-sequence ` ` ` `# which turns required ` ` ` `required_end_i ` `=` `(total_required_subsequence ` ` ` `+` `turn_required); ` ` ` ` ` `# Similarly for not required ` ` ` `n_required_end_i ` `=` `(` `1` `+` `total_n_required_subsequence ` ` ` `-` `turn_required); ` ` ` ` ` `# Also updating total required and ` ` ` `# not required sub-sequences ` ` ` `total_required_subsequence ` `+` `=` `required_end_i; ` ` ` `total_n_required_subsequence ` `+` `=` `n_required_end_i; ` ` ` ` ` `# Also, storing values in dp ` ` ` `dp[arr[i]][` `1` `] ` `+` `=` `required_end_i; ` ` ` `dp[arr[i]][` `0` `] ` `+` `=` `n_required_end_i; ` ` ` ` ` `return` `total_required_subsequence; ` ` ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `arr ` `=` `[ ` `1` `, ` `6` `, ` `2` `, ` `1` `, ` `9` `]; ` ` ` `n ` `=` `len` `(arr); ` ` ` ` ` `print` `(count_required_sequence(n, arr)) ; ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the above approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `static` `int` `N = 10000; ` ` ` ` ` `// Function to return the number of subsequences ` ` ` `// which have at least one consecutive pair ` ` ` `// with difference less than or equal to 1 ` ` ` `static` `int` `count_required_sequence(` `int` `n, ` `int` `[]arr) ` ` ` `{ ` ` ` `int` `total_required_subsequence = 0; ` ` ` `int` `total_n_required_subsequence = 0; ` ` ` `int` `[, ]dp = ` `new` `int` `[N, 2]; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` ` ` `// Not required sub-sequences which ` ` ` `// turn required on adding i ` ` ` `int` `turn_required = 0; ` ` ` `for` `(` `int` `j = -1; j <= 1; j++) ` ` ` `turn_required += dp[arr[i] + j, 0]; ` ` ` ` ` `// Required sub-sequence till now will be ` ` ` `// required sequence plus sub-sequence ` ` ` `// which turns required ` ` ` `int` `required_end_i = (total_required_subsequence ` ` ` `+ turn_required); ` ` ` ` ` `// Similarly for not required ` ` ` `int` `n_required_end_i = (1 + total_n_required_subsequence ` ` ` `- turn_required); ` ` ` ` ` `// Also updating total required and ` ` ` `// not required sub-sequences ` ` ` `total_required_subsequence += required_end_i; ` ` ` `total_n_required_subsequence += n_required_end_i; ` ` ` ` ` `// Also, storing values in dp ` ` ` `dp[arr[i], 1] += required_end_i; ` ` ` `dp[arr[i], 0] += n_required_end_i; ` ` ` `} ` ` ` ` ` `return` `total_required_subsequence; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[] arr = ` `new` `int` `[] { 1, 6, 2, 1, 9 }; ` ` ` `int` `n = arr.Length; ` ` ` ` ` `Console.WriteLine(count_required_sequence(n, arr)); ` ` ` `} ` `} ` ` ` `// This code has been contributed by ihritik ` |

*chevron_right*

*filter_none*

**Output:**

12

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Smallest subsequence with sum of absolute difference of consecutive elements maximized
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Find the difference of count of equal elements on the right and the left for each element
- Find the equal pairs of subsequence of S and subsequence of T
- Subarray with difference between maximum and minimum element greater than or equal to its length
- Longest Consecutive Subsequence
- Maximum subsequence sum such that no three are consecutive
- Longest Increasing consecutive subsequence
- Largest increasing subsequence of consecutive integers
- Minimum sum subsequence such that at least one of every four consecutive elements is picked
- Printing longest Increasing consecutive subsequence
- Maximize product of digit sum of consecutive pairs in a subsequence of length K
- Find maximum number of elements such that their absolute difference is less than or equal to 1
- Longest subsequence having equal numbers of 0 and 1
- Check whether a subsequence exists with sum equal to k if arr[i]> 2*arr[i-1]
- Longest Subarray with first element greater than or equal to Last element
- Replace two consecutive equal values with one greater
- Maximum difference between two elements such that larger element appears after the smaller number
- Length of Smallest Subsequence such that sum of elements is greater than equal to K
- Longest Subsequence where index of next element is arr[arr[i] + i]

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.