New update is available. Click here to update.

Last Updated: 25 Jul, 2020

Hard

```
1. Horizontally as 1x2 tile
2. Vertically as 2x1 tile
```

```
The number of ways might be large so output your answer modulo 10^9 + 7.
```

```
The first and only line of each test case contains an Integer 'N' which denotes the size of the board, i.e. '2' rows and 'N' columns.
```

```
For each test case, print the number of ways to tile the board modulo 10^9 + 7.
```

```
You are not required to print the output explicitly, it has already been taken care of. Just implement the function.
```

```
1 <= N <= 10^18
Where 'N' is the number of columns in the board.
Time limit: 1 sec
```

Approaches

Try to place the tile to fill the unit column and calculate the number of ways from smaller sub-problems. Then use memoization to convert O(2^N) solution to an O(N) solution.

- At any point we are at βidxβ column then we can place our tile in two ways to fill this column.
- Option 1 - 1 Horizontal Tile

We can place in this way where we have βidx-1β column filled.

2. Option 2 - 2 Vertical Tiles

We can place in this way where we have βidx-2β column filled.

2. So, numberOfWays(n) = numberOfWays(n-1) + numberOfWays(n-2)

3. Base cases are:

- When n = 1 there is only 1 way - Placing 1 Vertical Tile
- When n = 2 there are two ways - Placing 2 Vertical Tile and Placing 2 Horizontal Tiles.
- Also, take care of overflow using modulo 10^9 + 7.
- Lastly, use a DP Array of size N for memoization to save time over repetitive calls.

Try to place the tile to fill the unit column and calculate the number of ways from smaller sub-problems. We can use bottom-up DP with keeping the previous two values.

- At any point we are at βidxβ column then we can place our tile in two ways to fill this column.
- Option 1 - 1 Horizontal Tile

We can place in this way where we have βidx-1β column filled.

2. Option 2 - 2 Vertical Tiles

We can place in this way where we have βidx-2β column filled.

2. So, *numberOfWaysCur *= *numberOfWaysPre1 *+ *numberOfWaysPre2*

- Where
*numberOfWaysCur*is the number of ways to tile till 'current' column in the board. - Where
*numberOfWaysPre1*is the number of ways to tile till 'current-1' column in the board. - Where
*numberOfWaysPre2*is the number of ways to tile till 'current-2' column in the board. - Base cases are:When n = 1 there is only one way - Placing 1 Vertical Tile

*numberOfWaysPre2* = 1

When n = 2 there are two ways - Placing 2 Vertical Tile and Placing 2 Horizontal Tiles

*numberOfWaysPre1* = 2

5.Now Iterate from i=3 to N and keep updating the three variables.

6.Also, take care of overflow using modulo 10^9 + 7.

We can observe that the solution of this problem for 2xN Board is (N-1)th Fibonacci Number.

We can calculate the βNβth Fibonacci Number using Binary Matrix Exponentiation explained below. Here, Fn represents the n'th Fibonacci number. We will raise the matrix to the power of (n - 1) so that the top-left element gives the value of F(n + 1 - 1) = F(n).

```
[[1 1] (pow n) [[(F(n+1) F(n)]
[1 0]] = [F(n) F(n-1)]]
```

- So we need to find the (N - 1)th Power of this Matrix.
- We can write a function for the multiplication of two matrices.
- Then we can use binary exponentiation to calculate the βNβ power of this Matrix in log(N).
- Binary Exponentiation / Fast Exponentiation:

**long long binpow(Matrix a, long long b) {**

** if (b == 0)**

** return 1;**

** Matrix res = binpow(a, b / 2);**

** if (b % 2)**

** return res * res * a;**

** else**

** return res * res;**

**}**

- Similarly, we can write a version for Matrix Exponentiation.
- Take care of overflow using modulo by 10^9 + 7 at each operation of Matrix Multiplication.