Count ways to tile an N – length board using tiles of specified dimensions
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: 5
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 <bits/stdc++.h> 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
<script> // JavaScript program for above approach // Function to count the ways to tile N * 1 // board using 1 * 1 and 2 * 1 tiles function countWaysToTileBoard(N) { // dp[i]: Stores count of ways to tile // i * 1 board using given tiles let dp = []; // Base Case dp[0] = 1; dp[1] = 2; // Iterate over the range [2, N] for (let i = 2; i <= N; i++) { // Fill dp[i] using // the recurrence relation dp[i] = (2 * dp[i - 1] + dp[i - 2]); } document.write(dp[N]); } // Driver Code // Given N let N = 2; // Function Call countWaysToTileBoard(N); </script> |
5
Time Complexity: O(N)
Auxiliary Space: O(N)
Please Login to comment...