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 subsets``int` `countSubsets(``int` `N)``{``     ` `    ``if``(N <= 2)``        ``return` `N;``         ` `    ``if``(N == 3)``        ``return` `2;``     ` `    ``int` `DP[N + 1] = {0};``     ` `    ``DP = 0, DP = 1, DP = 2, DP = 2;``     ` `    ``for` `(``int` `i = 4; i <= N; i++) {`` ` `        ``DP[i] = DP[i - 2] + DP[i - 3];``    ``}``     ` `    ``return` `DP[N];``}`` ` `// Driver Code``int` `main()``{``    ``int` `N = 20;``     ` `    ``cout << countSubsets(N);``     ` `    ``return` `0;``}`

## Java

 `// Java code to count subsets not containing``// adjacent elements from 1 to N``class` `GFG{`` ` `// Function to count subsets``static` `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 code``public` `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 subsets``def` `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 Code``if` `__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 N``using` `System;``class` `GFG{`` ` `// Function to count subsets``static` `int` `countSubsets(``int` `N)``{``    ``if``(N <= 2)``        ``return` `N;``         ` `    ``if``(N == 3)``        ``return` `2;``     ` `    ``int` `[]DP = ``new` `int``[N + 1];``     ` `    ``DP = 0;``    ``DP = 1;``    ``DP = 2;``    ``DP = 2;``     ` `    ``for``(``int` `i = 4; i <= N; i++)``    ``{``        ``DP[i] = DP[i - 2] + DP[i - 3];``    ``}``    ``return` `DP[N];``}`` ` `// Driver code``public` `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