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

Examples:

Input: N = 2 
Output: 3 
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 <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)