Count possible ways to construct buildings - GeeksforGeeks

Count possible ways to construct buildings - GeeksforGeeks
Given an input number of sections and each section has 2 plots on either sides of the road. Find all possible ways to construct buildings in the plots such that there is a space between any 2 buildings.
N = 3
Output = 25
3 sections, which means possible ways for one side are
BSS, BSB, SSS, SBS, SSB where B represents a building
and S represents an empty space
Total possible ways are 25, because a way to place on
one side can correspond to any of 5 ways on other side.

We can simplify the problem to first calculate for one side only. If we know the result for one side, we can always do square of the result and get result for two sides.

A new building can be placed on a section if section just before it has space. A space can be placed anywhere (it doesn’t matter whether the previous section has a building or not).

Let countB(i) be count of possible ways with i sections
              ending with a building.
    countS(i) be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS(N) = countB(N-1) + countS(N-1)

// A building can only be added after a space.
countB[N] = countS(N-1)

// Result for one side is sum of the above two counts.
result1(N) = countS(N) + countB(N)

// Result for two sides is square of result1(N)
result2(N) = result1(N) * result1(N) 

int countWays(int N)

{

    // Base case

    if (N == 1)

        return 4;  // 2 for one side and 4 for two sides

 

    // countB is count of ways with a building at the end

    // countS is count of ways with a space at the end

    // prev_countB and prev_countS are previous values of

    // countB and countS respectively.

 

    // Initialize countB and countS for one side

    int countB=1, countS=1, prev_countB, prev_countS;

 

    // Use the above recursive formula for calculating

    // countB and countS using previous values

    for (int i=2; i<=N; i++)

    {

        prev_countB = countB;

        prev_countS = countS;

 

        countS = prev_countB + prev_countS;

        countB = prev_countS;

    }

 

    // Result for one side is sum of ways ending with building

    // and ending with space

    int result = countS + countB;

 

    // Result for 2 sides is square of result for one side

    return (result*result);

}

Optimized Solution:
Note that the above solution can be further optimized. If we take closer look at the results, for different values, we can notice that the results for two sides are squares of Fibonacci Numbers.

N = 1, result = 4 [result for one side = 2]
In general, we can say

  result(N) = fib(N+2)2
 
  fib(N) is a function that returns N'th
         Fibonacci Number.
 
Therefore, we can use O(LogN) implementation of Fibonacci Numbers to find number of ways in O(logN) time.

SImilar as: Count number of binary strings without consecutive 1's - GeeksforGeeks
Given a positive integer N, count all possible distinct binary strings of length N such that there are no consecutive 1's.
Let a[i] be the number of binary strings of length i which do not contain any two consecutive 1’s and which end in 0. Similarly, let b[i] be the number of such strings which end in 1.
We can append either 0 or 1 to a string ending in 0, but we can only append 0 to a string ending in 1. This yields the recurrence relation:
a[i] = a[i - 1] + b[i - 1]
b[i] = a[i - 1]
Read full article from Count possible ways to construct buildings - GeeksforGeeks