# Count non-adjacent subsets from numbers arranged in Circular fashion

Given that **N** people are sitting in a circular queue numbered from **1** to **N**, the task is to count the number of ways to select a subset of them such that no two consecutive are sitting together. The answer could be large, so compute the answer modulo **10 ^{9} + 7**.

**Note**that an empty subset is also a valid subset.

**Examples:**

Input:N = 2Output:3

All possible subsets are {}, {1} and {2}.

Input:N = 3Output:4

**Approach:** Let’s find the answer to small values of **N**.**N = 1** -> All possible subsets are **{}, {1}**. **N = 2** -> All possible subsets are **{}, {1}, {2}**. **N = 3** -> All possible subsets are **{}, {1}, {2}, {3}**. **N = 4** -> All possible subsets are **{}, {1}, {2}, {3}, {4}, {1, 3}, {2, 4}**.

So the sequence will be **2, 3, 4, 7, …**

When **N = 5** the count will be **11** and if **N = 6** then the count will be **18**.

It can now be observed that the sequence is similar to a Fibonacci series starting from the second term with the first two terms, 3 and 4.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define ll long long` `const` `ll N = 10000;` `const` `ll MOD = 1000000007;` `ll F[N];` `// Function to pre-compute the sequence` `void` `precompute()` `{` ` ` `// For N = 1 the answer will be 2` ` ` `F[1] = 2;` ` ` `// Starting two terms of the sequence` ` ` `F[2] = 3;` ` ` `F[3] = 4;` ` ` `// Compute the rest of the sequence` ` ` `// with the relation` ` ` `// F[i] = F[i - 1] + F[i - 2]` ` ` `for` `(` `int` `i = 4; i < N; i++)` ` ` `F[i] = (F[i - 1] + F[i - 2]) % MOD;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `n = 8;` ` ` `// Pre-compute the sequence` ` ` `precompute();` ` ` `cout << F[n];` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` `static` `int` `N = ` `10000` `;` `static` `int` `MOD = ` `1000000007` `;` `static` `int` `[]F = ` `new` `int` `[N];` `// Function to pre-compute the sequence` `static` `void` `precompute()` `{` ` ` `// For N = 1 the answer will be 2` ` ` `F[` `1` `] = ` `2` `;` ` ` `// Starting two terms of the sequence` ` ` `F[` `2` `] = ` `3` `;` ` ` `F[` `3` `] = ` `4` `;` ` ` `// Compute the rest of the sequence` ` ` `// with the relation` ` ` `// F[i] = F[i - 1] + F[i - 2]` ` ` `for` `(` `int` `i = ` `4` `; i < N; i++)` ` ` `F[i] = (F[i - ` `1` `] + F[i - ` `2` `]) % MOD;` `}` `// Driver code` `public` `static` `void` `main(String []args)` `{` ` ` `int` `n = ` `8` `;` ` ` `// Pre-compute the sequence` ` ` `precompute();` ` ` `System.out.println(F[n]);` `}` `}` `// This code is contributed by PrinciRaj1992` |

## Python3

`# Python implementation of the approach` `N ` `=` `10000` `;` `MOD ` `=` `1000000007` `;` `F ` `=` `[` `0` `] ` `*` `N;` `# Function to pre-compute the sequence` `def` `precompute():` ` ` `# For N = 1 the answer will be 2` ` ` `F[` `1` `] ` `=` `2` `;` ` ` `# Starting two terms of the sequence` ` ` `F[` `2` `] ` `=` `3` `;` ` ` `F[` `3` `] ` `=` `4` `;` ` ` `# Compute the rest of the sequence` ` ` `# with the relation` ` ` `# F[i] = F[i - 1] + F[i - 2]` ` ` `for` `i ` `in` `range` `(` `4` `,N):` ` ` `F[i] ` `=` `(F[i ` `-` `1` `] ` `+` `F[i ` `-` `2` `]) ` `%` `MOD;` `# Driver code` `n ` `=` `8` `;` `# Pre-compute the sequence` `precompute();` `print` `(F[n]);` `# This code is contributed by 29AjayKumar` |

## C#

`// C# implementation of the approach` `using` `System;` ` ` `class` `GFG` `{` `static` `int` `N = 10000;` `static` `int` `MOD = 1000000007;` `static` `int` `[]F = ` `new` `int` `[N];` `// Function to pre-compute the sequence` `static` `void` `precompute()` `{` ` ` `// For N = 1 the answer will be 2` ` ` `F[1] = 2;` ` ` `// Starting two terms of the sequence` ` ` `F[2] = 3;` ` ` `F[3] = 4;` ` ` `// Compute the rest of the sequence` ` ` `// with the relation` ` ` `// F[i] = F[i - 1] + F[i - 2]` ` ` `for` `(` `int` `i = 4; i < N; i++)` ` ` `F[i] = (F[i - 1] + F[i - 2]) % MOD;` `}` `// Driver code` `public` `static` `void` `Main(String []args)` `{` ` ` `int` `n = 8;` ` ` `// Pre-compute the sequence` ` ` `precompute();` ` ` `Console.WriteLine(F[n]);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` `// Javascript implementation of the approach` `var` `N = 10000;` `var` `MOD = 1000000007;` `var` `F = Array(N);` `// Function to pre-compute the sequence` `function` `precompute()` `{` ` ` `// For N = 1 the answer will be 2` ` ` `F[1] = 2;` ` ` `// Starting two terms of the sequence` ` ` `F[2] = 3;` ` ` `F[3] = 4;` ` ` `// Compute the rest of the sequence` ` ` `// with the relation` ` ` `// F[i] = F[i - 1] + F[i - 2]` ` ` `for` `(` `var` `i = 4; i < N; i++)` ` ` `F[i] = (F[i - 1] + F[i - 2]) % MOD;` `}` `// Driver code` `var` `n = 8;` `// Pre-compute the sequence` `precompute();` `document.write( F[n]);` `</script>` |

**Output:**

47

Time Complexity: O(N)

Auxiliary Space: O(N)