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

• Difficulty Level : Hard
• Last Updated : 25 May, 2022

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:
{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 exists a 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] will contain the number of sub sequence that do not have any consecutive pair with difference less than 1 and dp[i] 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 subsequences 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 …. arr[i], we will perform the following steps:

1. 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], dp[arr[i] – 1] and dp[arr[i]].
2. Total number of subsequences 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) + subsequences which turns into subsequence have at least consecutive pair with difference less than 1 on adding arr[i].
3. Total subsequence 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 subsequence).
4. Update required_sub-sequence, not_required_subsequence and dp[arr[i]] and the final answer will be required_subsequence.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``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];``    ``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];` `        ``// 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]] += required_end_i;``        ``dp[arr[i]] += 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;``}`

## Java

 `// Java implementation 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`

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

## C#

 `using` `System;` `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``    ``static` `public` `void` `Main ()``    ``{``        ` `        ``int``[] arr = { 1, 6, 2, 1, 9 };``        ``int` `n = arr.Length;``     ` `        ``Console.WriteLine(count_required_sequence(n, arr));``        ` `    ``}``}` `// This code is contributed by rag2127.`

## Javascript

 ``

Output:

`12`

Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(N), where N represents the size of the given array.

My Personal Notes arrow_drop_up