计算使用“1 x 4”瓷砖填充“nx 4”网格的方法数

给定一个数字 n，计算使用 1 x 4 瓷砖填充 anx 4 网格的方法数。
例子：

Input : n = 1
Output : 1

Input : n = 2
Output : 1
We can only place both tiles horizontally

Input : n = 3
Output : 1
We can only place all tiles horizontally.

Input : n = 4
Output : 2
The two ways are : 
  1) Place all tiles horizontally 
  2) Place all tiles vertically.

Input : n = 5
Output : 3
We can fill a 5 x 4 grid in following ways : 
  1) Place all 5 tiles horizontally
  2) Place first 4 vertically and 1 horizontally.
  3) Place first 1 horizontally and 4 horizontally.

我们强烈建议您在继续解决方案之前单击此处进行练习。

这个问题主要是这个平铺问题的延伸
让“count(n)”是在“nx 4”网格上放置瓷砖的方式的计数，当我们放置第一个瓷砖时会出现以下两种情况。

水平放置第一个瓷砖：如果我们水平放置第一个瓷砖，问题就简化为“count(n-1)”
垂直放置第一个瓷砖：如果我们垂直放置第一个瓷砖，那么我们必须垂直放置 3 个瓷砖。所以问题简化为“count(n-4)”

因此，count(n) 可以写成如下。

count(n) = 1 if n = 1 or n = 2 or n = 3   
   count(n) = 2 if n = 4
   count(n) = count(n-1) + count(n-4)

这种递归类似于斐波那契数列，可以使用动态规划解决。

C++

// C++ program to count of ways to place 1 x 4 tiles
// on n x 4 grid.
#include
using namespace std;
 
// Returns count of count of ways to place 1 x 4 tiles
// on n x 4 grid.
int count(int n)
{
    // Create a table to store results of subproblems
    // dp[i] stores count of ways for i x 4 grid.
    int dp[n+1];
    dp[0] = 0;
 
    // Fill the table from d[1] to dp[n]
    for (int i=1; i<=n; i++)
    {
        // Base cases
        if (i >= 1 && i <= 3)
            dp[i] = 1;
        else if (i==4)
            dp[i] = 2 ;
 
        else
            // dp(i-1) : Place first tile horizontally
            // dp(n-4) : Place first tile vertically
            //         which means 3 more tiles have
            //         to be placed vertically.
            dp[i] = dp[i-1] + dp[i-4];
    }
 
    return dp[n];
}
 
// Driver program to test above
int main()
{
    int n = 5;
    cout << "Count of ways is " << count(n);
    return 0;
}

Java

// Java program to count of ways to place 1 x 4 tiles
// on n x 4 grid
import java.io.*;
 
class Grid
{
    // Function that count the number of ways to place 1 x 4 tiles
    // on n x 4 grid.
    static int count(int n)
    {
        // Create a table to store results of sub-problems
        // dp[i] stores count of ways for i x 4 grid.
        int[] dp = new int[n+1];
        dp[0] = 0;
        // Fill the table from d[1] to dp[n]
        for(int i=1;i<=n;i++)
        {
            // Base cases
            if (i >= 1 && i <= 3)
                dp[i] = 1;
            else if (i==4)
                dp[i] = 2 ;
 
            else
            {
                    // dp(i-1) : Place first tile horizontally
                    // dp(i-4) : Place first tile vertically
                    //         which means 3 more tiles have
                    //         to be placed vertically.
                    dp[i] = dp[i-1] + dp[i-4];
            }
        }
        return dp[n];
    }
     
    // Driver program
    public static void main (String[] args)
    {
        int n = 5;
        System.out.println("Count of ways is: " + count(n));
    }
}
 
// Contributed by Pramod Kumar

Python

# Python program to count of ways to place 1 x 4 tiles
# on n x 4 grid.
 
# Returns count of count of ways to place 1 x 4 tiles
# on n x 4 grid.
def count(n):
 
    # Create a table to store results of subproblems
    # dp[i] stores count of ways for i x 4 grid.
    dp = [0 for _ in range(n+1)]
 
    # Fill the table from d[1] to dp[n]
    for i in range(1,n+1):
 
        # Base cases
        if i <= 3:
            dp[i] = 1
        elif i == 4:
            dp[i] = 2
        else:
            # dp(i-1) : Place first tile horizontally
            # dp(n-4) : Place first tile vertically
            #           which means 3 more tiles have
            #           to be placed vertically.
            dp[i] = dp[i-1] + dp[i-4]
 
    return dp[n]
 
# Driver code to test above
n = 5
print ("Count of ways is"),
print (count(n))

C#

// C# program to count of ways
// to place 1 x 4 tiles on
// n x 4 grid
using System;
 
class GFG
{
     
    // Function that count the number
    // of ways to place 1 x 4 tiles
    // on n x 4 grid.
    static int count(int n)
    {
         
        // Create a table to store results
        // of sub-problems dp[i] stores
        // count of ways for i x 4 grid.
        int[] dp = new int[n + 1];
        dp[0] = 0;
         
        // Fill the table from d[1]
        // to dp[n]
        for(int i = 1; i <= n; i++)
        {
             
            // Base cases
            if (i >= 1 && i <= 3)
                dp[i] = 1;
            else if (i == 4)
                dp[i] = 2 ;
 
            else
            {
                 
                // dp(i-1) : Place first tile
                // horizontally dp(i-4) :
                // Place first tile vertically
                // which means 3 more tiles have
                // to be placed vertically.
                dp[i] = dp[i - 1] +
                        dp[i - 4];
            }
        }
        return dp[n];
    }
     
    // Driver Code
    public static void Main ()
    {
        int n = 5;
        Console.WriteLine("Count of ways is: "
                           + count(n));
    }
}
 
// This code is contributed by Sam007

PHP

= 1 && $i <= 3)
            $dp[$i] = 1;
        else if ($i == 4)
            $dp[$i] = 2 ;
 
        else
            // dp(i-1) : Place first tile horizontally
            // dp(n-4) : Place first tile vertically
            //             which means 3 more tiles have
            //             to be placed vertically.
            $dp[$i] = $dp[$i - 1] + $dp[$i - 4];
    }
 
    return $dp[$n];
}
 
    // Driver Code
    $n = 5;
    echo "Count of ways is " , countt($n);
 
// This code is contributed by nitin mittal.
?>

Javascript

输出：

Count of ways is 3

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。