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 = 4Output:3Explanation:Array is {1, 2, 3, 4} So to satisfy the condition, the subsets formed are : {1, 3}, {2, 4}, {1, 4}Input:N = 5Output: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 <bits/stdc++.h>` `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] = 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` `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] = 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;` ` ` ` ` `Console.Write(countSubsets(N));` `}` `}` `// This code is contributed by sapnasingh4991` |

## Javascript

`<script>` `// javascript code to count subsets not containing` `// adjacent elements from 1 to N ` `// Function to count subsets` ` ` `function` `countSubsets(N) {` ` ` `if` `(N <= 2)` ` ` `return` `N;` ` ` `if` `(N == 3)` ` ` `return` `2;` ` ` `var` `DP = Array(N + 1).fill(0);` ` ` `DP[0] = 0;` ` ` `DP[1] = 1;` ` ` `DP[2] = 2;` ` ` `DP[3] = 2;` ` ` `for` `(i = 4; i <= N; i++) {` ` ` `DP[i] = DP[i - 2] + DP[i - 3];` ` ` `}` ` ` `return` `DP[N];` ` ` `}` ` ` `// Driver code` ` ` ` ` `var` `N = 20;` ` ` `document.write(countSubsets(N));` `// This code contributed by gauravrajput1` `</script>` |

**Output:**

265

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