Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 25 May, 2022
View Discussion
Improve Article
Save Article

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][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 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[1] …. 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][0], dp[arr[i] – 1][0] and dp[arr[i]][0].
  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][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;
}

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




<script>
 
// Javascript implementation of the approach
var N = 10000;
 
// Function to return the number of subsequences
// which have at least one consecutive pair
// with difference less than or equal to 1
function count_required_sequence(n, arr)
{
    var total_required_subsequence = 0;
    var total_n_required_subsequence = 0;
    var dp = Array.from(Array(N), ()=> Array(2).fill(0));
    for (var i = 0; i < n; i++) {
 
        // Not required sub-sequences which
        // turn required on adding i
        var turn_required = 0;
        for (var 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
        var required_end_i = (total_required_subsequence
                              + turn_required);
 
        // Similarly for not required
        var 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
var arr = [ 1, 6, 2, 1, 9 ];
var n = arr.length;
document.write( count_required_sequence(n, arr) + "<br>");
 
</script>

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
Recommended Articles
Page :

Start Your Coding Journey Now!