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

## Recommended Posts:

- Find maximum number of elements such that their absolute difference is less than or equal to 1
- Maximum subsequence sum such that no three are consecutive
- Longest Consecutive Subsequence
- Longest Increasing consecutive subsequence
- Printing 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
- Maximum difference between two elements such that larger element appears after the smaller number
- Longest Subarray with first element greater than or equal to Last element
- Check whether a subsequence exists with sum equal to k if arr[i]> 2*arr[i-1]
- Longest subsequence having equal numbers of 0 and 1
- Replace each element by the difference of the total size of the array and frequency of that element
- Replace two consecutive equal values with one greater
- Longest subsequence such that difference between adjacents is one | Set 2
- Longest subsequence such that difference between adjacents is one

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.