Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of subsets not containing adjacent elements

  • Last Updated : 27 May, 2021

Given an array arr[] of N integers, the task is to find the count of all the subsets which do not contain adjacent elements from the given array.

Examples:  

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {2, 7} 
Output: 3 
All possible subsets are {}, {2} and {7}.



Input: arr[] = {3, 5, 7} 
Output: 5  

Method 1: The idea is to use a bit-mask pattern to generate all the combinations as discussed in this article. While considering a subset, we need to check if it contains adjacent elements or not. A subset will contain adjacent elements if two or more consecutive bits are set in its bit-mask. In order to check if the bit-mask has consecutive bits set or not, we can right shift the mask by one bit and take it AND with the mask. If the result of the AND operation is 0, then the mask does not have consecutive sets and therefore, the corresponding subset will not have adjacent elements from the array.
Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <iostream>
#include <math.h>
using namespace std;
 
// Function to return the count
// of possible subsets
int cntSubsets(int* arr, int n)
{
 
    // Total possible subsets of n
    // sized array is (2^n - 1)
    unsigned int max = pow(2, n);
 
    // To store the required
    // count of subsets
    int result = 0;
 
    // Run from i 000..0 to 111..1
    for (int i = 0; i < max; i++) {
        int counter = i;
 
        // If current subset has consecutive
        // elements from the array
        if (counter & (counter >> 1))
            continue;
        result++;
    }
    return result;
}
 
// Driver code
int main()
{
    int arr[] = { 3, 5, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << cntSubsets(arr, n);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
     
class GFG
{
 
// Function to return the count
// of possible subsets
static int cntSubsets(int[] arr, int n)
{
 
    // Total possible subsets of n
    // sized array is (2^n - 1)
    int max = (int) Math.pow(2, n);
 
    // To store the required
    // count of subsets
    int result = 0;
 
    // Run from i 000..0 to 111..1
    for (int i = 0; i < max; i++)
    {
        int counter = i;
 
        // If current subset has consecutive
        if ((counter & (counter >> 1)) > 0)
            continue;
        result++;
    }
    return result;
}
 
// Driver code
static public void main (String []arg)
{
    int arr[] = { 3, 5, 7 };
    int n = arr.length;
 
    System.out.println(cntSubsets(arr, n));
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation of the approach
 
# Function to return the count
# of possible subsets
def cntSubsets(arr, n):
 
    # Total possible subsets of n
    # sized array is (2^n - 1)
    max = pow(2, n)
 
    # To store the required
    # count of subsets
    result = 0
 
    # Run from i 000..0 to 111..1
    for i in range(max):
        counter = i
 
        # If current subset has consecutive
        # elements from the array
        if (counter & (counter >> 1)):
            continue
        result += 1
 
    return result
 
# Driver code
arr = [3, 5, 7]
n = len(arr)
 
print(cntSubsets(arr, n))
 
# This code is contributed by Mohit Kumar
C#



// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to return the count
// of possible subsets
static int cntSubsets(int[] arr, int n)
{
 
    // Total possible subsets of n
    // sized array is (2^n - 1)
    int max = (int) Math.Pow(2, n);
 
    // To store the required
    // count of subsets
    int result = 0;
 
    // Run from i 000..0 to 111..1
    for (int i = 0; i < max; i++)
    {
        int counter = i;
 
        // If current subset has consecutive
        if ((counter & (counter >> 1)) > 0)
            continue;
        result++;
    }
    return result;
}
 
// Driver code
static public void Main (String []arg)
{
    int []arr = { 3, 5, 7 };
    int n = arr.Length;
 
    Console.WriteLine(cntSubsets(arr, n));
}
}
     
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to return the count
// of possible subsets
function cntSubsets(arr, n)
{
 
    // Total possible subsets of n
    // sized array is (2^n - 1)
    var max = Math.pow(2, n);
 
    // To store the required
    // count of subsets
    var result = 0;
 
    // Run from i 000..0 to 111..1
    for (var i = 0; i < max; i++) {
        var counter = i;
 
        // If current subset has consecutive
        // elements from the array
        if (counter & (counter >> 1))
            continue;
        result++;
    }
    return result;
}
 
// Driver code
var arr = [3, 5, 7];
var n = arr.length;
document.write( cntSubsets(arr, n));
 
 
</script>
Output: 
5
 
Method 2: The above approach takes exponential time. In the above code, the number of bit-masks without consecutive 1s was required. This count can be obtained in linear time using dynamic programming as discussed in this article.
Below is the implementation of the above approach:  
C++



// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Function to return the count
// of possible subsets
int cntSubsets(int* arr, int n)
{
    int a[n], b[n];
 
    a[0] = b[0] = 1;
 
    for (int i = 1; i < n; i++) {
 
        // If previous element was 0 then 0
        // as well as 1 can be appended
        a[i] = a[i - 1] + b[i - 1];
 
        // If previous element was 1 then
        // only 0 can be appended
        b[i] = a[i - 1];
    }
 
    // Store the count of all possible subsets
    int result = a[n - 1] + b[n - 1];
 
    return result;
}
 
// Driver code
int main()
{
    int arr[] = { 3, 5, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << cntSubsets(arr, n);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return the count
// of possible subsets
static int cntSubsets(int []arr, int n)
{
    int []a = new int[n];
    int []b = new int[n];
 
    a[0] = b[0] = 1;
 
    for (int i = 1; i < n; i++)
    {
 
        // If previous element was 0 then 0
        // as well as 1 can be appended
        a[i] = a[i - 1] + b[i - 1];
 
        // If previous element was 1 then
        // only 0 can be appended
        b[i] = a[i - 1];
    }
 
    // Store the count of all possible subsets
    int result = a[n - 1] + b[n - 1];
 
    return result;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 5, 7 };
    int n = arr.length;
 
    System.out.println(cntSubsets(arr, n));
}
}
 
// This code is contributed by Princi Singh
Python3



# Python3 implementation of the approach
 
# Function to return the count
# of possible subsets
def cntSubsets(arr, n) :
 
    a = [0] * n
    b = [0] * n;
 
    a[0] = b[0] = 1;
 
    for i in range(1, n) :
         
        # If previous element was 0 then 0
        # as well as 1 can be appended
        a[i] = a[i - 1] + b[i - 1];
 
        # If previous element was 1 then
        # only 0 can be appended
        b[i] = a[i - 1];
 
    # Store the count of all possible subsets
    result = a[n - 1] + b[n - 1];
 
    return result;
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 3, 5, 7 ];
    n = len(arr);
 
    print(cntSubsets(arr, n));
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
     
class GFG
{
 
// Function to return the count
// of possible subsets
static int cntSubsets(int []arr, int n)
{
    int []a = new int[n];
    int []b = new int[n];
 
    a[0] = b[0] = 1;
 
    for (int i = 1; i < n; i++)
    {
 
        // If previous element was 0 then 0
        // as well as 1 can be appended
        a[i] = a[i - 1] + b[i - 1];
 
        // If previous element was 1 then
        // only 0 can be appended
        b[i] = a[i - 1];
    }
 
    // Store the count of all possible subsets
    int result = a[n - 1] + b[n - 1];
 
    return result;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3, 5, 7 };
    int n = arr.Length;
 
    Console.WriteLine(cntSubsets(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to return the count
// of possible subsets
function cntSubsets(arr, n)
{
    var a = Array(n);
    var b = Array(n);
 
    a[0] = b[0] = 1;
 
    for (var i = 1; i < n; i++) {
 
        // If previous element was 0 then 0
        // as well as 1 can be appended
        a[i] = a[i - 1] + b[i - 1];
 
        // If previous element was 1 then
        // only 0 can be appended
        b[i] = a[i - 1];
    }
 
    // Store the count of all possible subsets
    var result = a[n - 1] + b[n - 1];
 
    return result;
}
 
// Driver code
var arr = [3, 5, 7 ];
var n = arr.length;
document.write( cntSubsets(arr, n));
 
</script>
Output: 
5
 
Method 3; If we take a closer look at the pattern, we can observe that the count is actually (N + 2)th Fibonacci number for N ≥ 1.  
n = 1, count = 2 = fib(3) 
n = 2, count = 3 = fib(4) 
n = 3, count = 5 = fib(5) 
n = 4, count = 8 = fib(6) 
n = 5, count = 13 = fib(7) 
……………. 
Therefore, the subsets can be counted in O(log n) time using method 5 of this article.
 



My Personal Notes
arrow_drop_up
Next

Maximum sum such that no two elements are adjacent
Recommended Articles
Page :
Count of Subsets containing only the given value K
21, Apr 20
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Count of subsets of integers from 1 to N having no adjacent elements
29, Apr 20
Generate N-size Array with equal difference of adjacent elements containing given numbers A and B
10, Aug 21
Sum of subsets of all the subsets of an array | O(3^N)
30, Oct 19
Sum of subsets of all the subsets of an array | O(2^N)
31, Oct 19
Sum of subsets of all the subsets of an array | O(N)
31, Oct 19
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Count non-adjacent subsets from numbers arranged in Circular fashion
29, Oct 19
Count of ways N elements can form two different sets containing N/2 elements each
17, Nov 21
Count the number of ordered sets not containing consecutive numbers
29, Apr 20
Rearrange given Array such that each elements is not equal to mean of adjacent elements
17, Aug 21
Minimize count of Subsets with difference between maximum and minimum element not exceeding K
21, Aug 20
Find Kth element in an array containing odd elements first and then even elements
03, Sep 19
Split an array containing N elements into K sets of distinct elements
31, May 20
Count of subsequences of length atmost K containing distinct prime elements
29, May 20
Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
11, Jul 19
Count of array elements which is smaller than both its adjacent elements
22, May 20
Partition an array into two subsets with equal count of unique elements
29, Jun 21
Permutation of Array such that sum of adjacent elements are not divisible by 3
15, Jul 20
Maximum possible sum of non-adjacent array elements not exceeding K
14, Oct 20
Count of N-digit numbers with absolute difference of adjacent digits not exceeding K
08, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aganjali10
@aganjali10
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!