# Count ways to tile an N – length board using tiles of specified dimensions

• Difficulty Level : Medium
• Last Updated : 21 Apr, 2021

Given an integer N, the task is to tile a board of dimensions N * 1 the task is to count the number of ways to tile a board using tiles of dimensions 1 * 1 and 2 * 1.

Examples:

Input: N = 2
Output:
Explanation:
Tile the board of size 2 x 1 by placing 1 x 1 tile in a Horizontal way and another 1 x 1 tile in a vertical way.
Tile the board of size 2 x 1 by placing 1 x 1 tile in a vertical way and another 1 x 1 tile in a Horizontal way.
Tile the board of size 2 x 1 by placing 1 x 1 tile in a Horizontal way and another 1 x 1 tile in a Horizontal way.
Tile the board of size 2 x 1 by placing 1 x 1 tile in a vertical way and another 1 x 1 tile in a vertical way.
Tile the board of size 2 x 1 by placing 2 x 1 tile in a horizontal way.
Therefore, the required output is 5.

Input: N = 1
Output: 2

Approach: The problem can be solved using Dynamic Programming. The idea is to divide the N x 1 board into smaller boards, then count the ways to tile the smaller boards. Finally, print the total count of ways to tile the N x 1 board. Follow the steps below to solve the problem:

• Following are the three ways to place the first tile:
• Place the 1 x 1 tile vertically.
• Place the 1 x 1 tile horizontally.
• Place the 2 x 1 tile horizontally.
• Therefore, the recurrence relation to solve the problem is as follows:

cntWays(N) = 2 * cntWays(N – 1) + cntWays(N – 2)

• Initialize an array say, dp[], where dp[i] stores the count of ways to tile the i x 1 board.
• Iterate over the range [2, N] and fill the array, dp[] using the tabulation method.
• Finally, print the value of dp[N].

Below is the implementation of the above approach:

## C++

 // C++ Program to implement // the above approach   #include using namespace std;     // Function to count the ways to tile N * 1 // board using 1 * 1 and 2 * 1 tiles long countWaysToTileBoard(long N) {           // dp[i]: Stores count of ways to tile     // i * 1 board using given tiles     long dp[N + 1];       // Base Case     dp[0] = 1;     dp[1] = 2;           // Iterate over the range [2, N]     for (int i = 2; i <= N; i++) {           // Fill dp[i] using         // the recurrence relation         dp[i] = (2 * dp[i - 1]                     + dp[i - 2] );     }       cout << dp[N]; }       // Driver Code int main() {     // Given N     long N = 2;       // Function Call     countWaysToTileBoard(N);       return 0; }

## Java

 // Java program to implement // the above approach class GFG{       // Function to count the ways to tile N * 1 // board using 1 * 1 and 2 * 1 tiles static void countWaysToTileBoard(int N) {           // dp[i]: Stores count of ways to tile     // i * 1 board using given tiles     int dp[] = new int[N + 1];           // Base Case     dp[0] = 1;     dp[1] = 2;           // Iterate over the range [2, N]     for(int i = 2; i <= N; i++)     {                   // Fill dp[i] using         // the recurrence relation         dp[i] = (2 * dp[i - 1] +                      dp[i - 2]);     }     System.out.print(dp[N]); }   // Driver Code public static void main (String[] args) {           // Given N     int N = 2;           // Function Call     countWaysToTileBoard(N); } }   // This code is contributed by AnkThon

## Python3

 # Python3 program to implement # the above approach   # Function to count the ways to tile N * 1 # board using 1 * 1 and 2 * 1 tiles def countWaysToTileBoard( N) :           # dp[i]: Stores count of ways to tile     # i * 1 board using given tiles     dp = [0]*(N + 1)       # Base Case     dp[0] = 1     dp[1] = 2           # Iterate over the range [2, N]     for i in range(2, N + 1) :           # Fill dp[i] using         # the recurrence relation         dp[i] = (2 * dp[i - 1] + dp[i - 2] )           print(dp[N])   # Driver Code if __name__ == "__main__" :           # Given N     N = 2       # Function Call     countWaysToTileBoard(N)         # This code is contributed by jana_sayantan

## C#

 // C# program to implement // the above approach using System;   class GFG{       // Function to count the ways to tile N * 1 // board using 1 * 1 and 2 * 1 tiles static void countWaysToTileBoard(int N) {           // dp[i]: Stores count of ways to tile     // i * 1 board using given tiles     int []dp = new int[N + 1];           // Base Case     dp[0] = 1;     dp[1] = 2;           // Iterate over the range [2, N]     for(int i = 2; i <= N; i++)     {                   // Fill dp[i] using         // the recurrence relation         dp[i] = (2 * dp[i - 1] +                      dp[i - 2]);     }     Console.Write(dp[N]); }   // Driver Code public static void Main(String[] args) {           // Given N     int N = 2;           // Function Call     countWaysToTileBoard(N); } }   // This code is contributed by shikhasingrajput

## Javascript



Output:

5

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles