 Open in App
Not now

# 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 = 1;` `    ``dp = 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 = 1;` `    ``dp = 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