Related Articles
Count of subsets of integers from 1 to N having no adjacent elements
• Last Updated : 09 Jun, 2020

Given an integer N, the task is to count the number of subsets formed from an array of integers from 1 to N which doesn’t contain adjacent elements. A subset can’t be chosen if it satisfies the non-adjacent element condition but it is possible to add more elements.

Examples:

Input: N = 4
Output: 3
Explanation:
Array is {1, 2, 3, 4}
So to satisfy the condition, the subsets formed are :
{1, 3}, {2, 4}, {1, 4}

Input: N = 5
Output: 4

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
This problem can be solved by using Dynamic Programming. For the last element, we have two choices, either we include it, or we exclude it. Let DP[i] be the number of our desirable subsets ending at index i.

If we select ith index, then we can’t select (i-1)th index, but we can select (i-2)th index. This makes DP[i-2] our new subproblem.
If we don’t select ith index, then we have to select (i-1)th index, and further cannot select (i-2)th index, but can select (i-3)rd index.

So next Subproblem becomes DP[i-3]

So the DP relation becomes :

DP[i] = DP[i-2] + DP[i-3]

But, we need to observe the base cases:

• When N=0, we cannot form any subset with 0 numbers.
• When N=1, we can form 1 subset, {1}
• When N=2, we can form 2 subsets, {1}, {2}
• When N=3, we can form 2 subsets, {1, 3}, {2}

Below is the implementation of above approach:

## C++

 // C++ Code to count subsets not containing// adjacent elements from 1 to N  #include using namespace std;  // Function to count subsetsint countSubsets(int N){          if(N <= 2)        return N;              if(N == 3)        return 2;          int DP[N + 1] = {0};          DP[0] = 0, DP[1] = 1, DP[2] = 2, DP[3] = 2;          for (int i = 4; i <= N; i++) {          DP[i] = DP[i - 2] + DP[i - 3];    }          return DP[N];}  // Driver Codeint main(){    int N = 20;          cout << countSubsets(N);          return 0;}

## Java

 // Java code to count subsets not containing// adjacent elements from 1 to Nclass GFG{  // Function to count subsetsstatic int countSubsets(int N){    if(N <= 2)       return N;              if(N == 3)       return 2;          int []DP = new int[N + 1];          DP[0] = 0;    DP[1] = 1;    DP[2] = 2;    DP[3] = 2;          for(int i = 4; i <= N; i++)    {       DP[i] = DP[i - 2] + DP[i - 3];    }    return DP[N];}  // Driver codepublic static void main(String[] args){    int N = 20;          System.out.print(countSubsets(N));}}  // This code is contributed by sapnasingh4991

## Python3

 # Python3 Code to count subsets # not containing adjacent elements# from 1 to N  # Function to count subsetsdef countSubsets(N):      if(N <= 2):        return N      if(N == 3):        return 2      DP = [0] * (N + 1)      DP[0] = 0    DP[1] = 1    DP[2] = 2    DP[3] = 2      for i in range(4, N + 1):          DP[i] = DP[i - 2] + DP[i - 3]      return DP[N]  # Driver Codeif __name__ == '__main__':    N = 20      print(countSubsets(N))      # This code is contributed by Mohit Kumar

## C#

 // C# code to count subsets not containing// adjacent elements from 1 to Nusing System;class GFG{  // Function to count subsetsstatic int countSubsets(int N){    if(N <= 2)        return N;              if(N == 3)        return 2;          int []DP = new int[N + 1];          DP[0] = 0;    DP[1] = 1;    DP[2] = 2;    DP[3] = 2;          for(int i = 4; i <= N; i++)    {        DP[i] = DP[i - 2] + DP[i - 3];    }    return DP[N];}  // Driver codepublic static void Main(String[] args){    int N = 20;          Console.Write(countSubsets(N));}}  // This code is contributed by sapnasingh4991
Output:
265

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.

My Personal Notes arrow_drop_up