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

• Last Updated : 07 Mar, 2022

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 109 + 7. Note that an empty subset is also a valid subset.

Examples:

Input: N = 2
Output:
All possible subsets are {}, {1} and {2}.

Input: N = 3
Output: 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 ``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 = 2;` `    ``// Starting two terms of the sequence``    ``F = 3;``    ``F = 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 = 2;` `    ``// Starting two terms of the sequence``    ``F = 3;``    ``F = 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

 ``

Output:

`47`

Time Complexity: O(N)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up