Skip to content
Related Articles
Count of subsets of integers from 1 to N having no adjacent elements
• Last Updated : 21 Apr, 2021

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

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

## Javascript

 ``
Output:
`265`

Attention reader! Don’t stop learning now. Get hold of all the important Comcompetitivepetitve Programming concepts with the Competitive Programming Live  course.

My Personal Notes arrow_drop_up