# 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
{"found_math": false, "script_math_tex": 0, "script_math_asciimath": 0, "math_annotations": 0, "math_alttext": 0, "mathml": 0, "mathjax_tag": 0, "mathjax_inline_tex": 0, "mathjax_display_tex": 0, "mathjax_asciimath": 0, "img_math": 0, "codecogs_latex": 0, "wp_latex": 0, "mimetex.cgi": 0, "/images/math/codecogs": 0, "mathtex.cgi": 0, "katex": 0, "math-container": 0, "wp-katex-eq": 0, "align": 0, "equation": 0, "x-ck12": 0, "texerror": 0}