leetcode 790. Domino and Tromino Tiling

最新推荐文章于 2025-06-14 18:42:24 发布

原创最新推荐文章于 2025-06-14 18:42:24 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #python

leetcode 同时被 3 个专栏收录

13 篇文章

订阅专栏

python

13 篇文章

订阅专栏

math

4 篇文章

订阅专栏

该博客讨论了LeetCode 790题，涉及使用2x1的多米诺骨牌和L型Tromino来铺满2xN的棋盘的不同方法。博主提供了两种解决方案：动态规划和矩阵快速幂。动态规划方法通过递推公式`dp[n] = dp[n-1] + dp[n-2] + 2 * Σ dpi`计算，而矩阵乘法方法利用线性代数在O(logN)时间内完成计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

leetcode 790. Domino and Tromino Tiling

leetcode 790. Domino and Tromino Tiling

题目描述

We have two types of tiles: a 2x1 domino shape, and an “L” tromino shape. These shapes may be rotated.
——————————————————
XX <- domino

XX <- “L” tromino
X
——————————————————

Given N, how many ways are there to tile a 2 x N board? Return your answer modulo 10^9 + 7.
(In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.)

Note:

N will be in range [1, 1000].

Difficulty: medium
790. Domino and Tromino Tiling

中文描述
你拥有两种形状的多米诺骨牌，一种是XX这样 2x1 形状的，还有一种是L型的。问铺满 2xN 的空间，一共能有多少种不同的方法。结果对10^9 + 7取余数。

输入格式
输入一个值N，表示长度。

Examples:

Input: 3
Output: 5
解释:
总共有5中方法组成 2X3 的矩形
XYZ XXZ XYY XXY XYY
XYZ YYZ XZZ XYY XXY

解答思路

解法一：dp解法

1.可以从图里看出， $n = 1和n=2$ 的时候为基础情况，在 $n = 3$ 开始就能发现一定规律。 $n = 3$ 的第一行，是由 $n = 2$ 的情况加上一个2X1的多米诺牌放在末尾组成的。 $n = 3$ 的第二行的前半部分是由 $n = 1$ 的情况加上两个2X1的多米诺牌横放，放在末尾组成的。 $n = 3$ 的第二行的后半部分则是不由 $n = 1，2$ 的情况组成的。同理 $n = 4$ 的第一行，是由 $n = 3$ 的情况加上一个2X1的多米诺牌放在末尾组成的。 $n = 4$ 的第二行是由 $n = 2$ 的情况加上两个2X1的多米诺牌横放，放在末尾组成的。 $n = 4$ 的第三行的前半部分则是由 $n = 1$ 加上两个L型的多米诺牌放在末尾组成的。 $n = 4$ 的第三行的后半部分则是不由 $n = 1，2，3$ 的情况组成的。

2.从上我们的大概可以总结规律，每个 $n$ 都是由之前 $n-1$ 的情况配合组成的。 $dp_{n}$ 表示第 $2\times n$ 个的组合个数。
其公式为 $dp_{n}=dp_{n-1}+dp_{n-2}+2 \times\sum\limits_{i = 0}^{n-3}dp_{i},其中dp_{0}=1$ 。 $dp_{n-1}$ 表示以一个2X1的多米诺牌放在末尾组成的， $dp_{n-2}$ 表示以两个2X1的多米诺牌横放，放在末尾组成的，剩下的则是由带有L型为末尾的。结尾形状具体可以看下图：

在 $n - 3$ 以后都是有2种，所以需要乘2.

3.上述式子可以简化，用 $dp_{n} - dp_{n-1} =dp_{n-1}+dp_{n-2}+2 \times\sum\limits_{i = 0}^{n-3}dp_{i} - \left( dp_{n-2}+dp_{n-3}+2 \times\sum\limits_{i = 0}^{n-4}dp_{i}\right)$ ，化简得到 $dp_{n}=2dp_{n-1}-dp_{n-3}$ 。这就是递推方程。

4.复杂度估计 $O\left(n \right)$
解法二：矩阵乘法

1. $dp_{n}=dp_{n-1}+dp_{n-2}+2 \times\sum\limits_{i = 0}^{n-3}dp_{i},其中dp_{0}=1$ ，写成矩阵形式为
$[a 1 b 1 c 1] \times ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ d p n - 1 d p n - 2 \sum i = 0 n - 3 d p i ⎤ ⎦ ⎥ ⎥ ⎥ ⎥ = [a 2 b 2 c 2] \times ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ d p n - 2 d p n - 3 \sum i = 0 n - 4 d p i ⎤ ⎦ ⎥ ⎥ ⎥ ⎥ = . . . = [a n - 2 b n - 2 c n - 2] \times ⎡ ⎣ ⎢ d p 2 d p 1 d p 0 ⎤ ⎦ ⎥ = 2 a n - 2 + b n - 2 + c n - 2$ $\left[\begin{matrix}a_{1} & b_{1} & c_{1} \end{matrix}\right] \times \left[\begin{matrix}dp_{n-1} \\dp_{n-2} \\\sum\limits_{i = 0}^{n-3}dp_{i} \end{matrix}\right]=\left[\begin{matrix}a_{2} & b_{2} & c_{2} \end{matrix}\right] \times \left[\begin{matrix}dp_{n-2} \\dp_{n-3} \\\sum\limits_{i = 0}^{n-4}dp_{i} \end{matrix}\right]=...\\=\left[\begin{matrix}a_{n-2} & b_{n-2} & c_{n-2} \end{matrix}\right] \times \left[\begin{matrix}dp_{2} \\dp_{1} \\dp_{0} \end{matrix}\right]=2a_{n-2}+b_{n-2}+c_{n-2}$
其中 $a_{1}=1,b_{1}=1,c_{1}=2$ 。
我们取 $\left[\begin{matrix}a_{k-1} & b_{k-1} & c_{k-1} \end{matrix}\right] \times \left[\begin{matrix}dp_{n-k+1} \\dp_{n-k} \\\sum\limits_{i = 0}^{n-k-1}dp_{i} \end{matrix}\right]$
由于 $a_{k-1}\times dp_{n-k+1}= a_{k-1}\times\left(dp_{n-k}+dp_{n-k-1}+2\sum\limits_{i = 0}^{n-k-2}dp_{i} \right)$
所以上面矩阵乘法结果为 $a_{k-1}\times\left(dp_{n-k}+dp_{n-k-1}+2\sum\limits_{i = 0}^{n-k-2}dp_{i} \right)+b_{k-1}\times dp_{n-k}+c_{k-1}\times\sum\limits_{i = 0}^{n-k-1}dp_{i}$
$=\left(a_{k-1}+b_{k-1}\right)dp_{n-k}+\left(a_{k-1}+c_{k-1}\right)dp_{n-k-1}+\left(2a_{k-1}+c_{k-1}\right)\sum\limits_{i = 0}^{n-k-2}dp_{i}$
$=\left[\begin{matrix}a_{k} & b_{k} & c_{k} \end{matrix}\right] \times \left[\begin{matrix}dp_{n-k} \\dp_{n-k-1} \\\sum\limits_{i = 0}^{n-k-2}dp_{i} \end{matrix}\right]$ ，
可以得到:
$a_{k}=a_{k-1}+b_{k-1}\\b_{k}=a_{k-1}+c_{k-1}\\c_{k}=2a_{k-1}+c_{k-1}$
进一步:
$a_{k}=a_{k-2}+b_{k-2}+a_{k-2}+c_{k-2}=2a_{k-2}+b_{k-2}+c_{k-2}\\b_{k}=3a_{k-2}+b_{k-2}+c_{k-2}\\c_{k}=4a_{k-2}+b_{k-2}+c_{k-2}$ 。
转化为矩阵形式为:
$\left[\begin{matrix}a_{n-2} & b_{n-2} & c_{n-2} \end{matrix}\right]\times \left[\begin{matrix}2 \\ 1 \\ 1 \end{matrix}\right]\\=\left[\begin{matrix}a_{n-4} & b_{n-4} & c_{n-4} \end{matrix}\right]\times \left[\begin{matrix}2 &3 &4\\ 1 &1 &2\\ 1 &1 &1 \end{matrix}\right]\times \left[\begin{matrix}2 \\ 1 \\ 1 \end{matrix}\right]\\=\left[\begin{matrix}a_{n-2k} & b_{n-2k} & c_{n-2k} \end{matrix}\right]\times \left[\begin{matrix}2 &3 &4\\ 1 &1 &2\\ 1 &1 &1 \end{matrix}\right]^{k-1}\times \left[\begin{matrix}2 \\ 1 \\ 1 \end{matrix}\right]$
如果 $n$ 为偶数， $\left[\begin{matrix}a_{n-2k} & b_{n-2k} & c_{n-2k} \end{matrix}\right]$ 最小从下标2开始
$\left[\begin{matrix}a_{2} & b_{2} & c_{2} \end{matrix}\right]=\left[\begin{matrix}a_{1}+b_{1} & a_{1}+c_{1} & 2a_{1}+c_{1} \end{matrix}\right]=\left[\begin{matrix}2 & 3& 4 \end{matrix}\right]$
如果 $n$ 为奇数 $\left[\begin{matrix}a_{n-2k} & b_{n-2k} & c_{n-2k} \end{matrix}\right]$ 最小从下标1开始
$\left[\begin{matrix}a_{1} & b_{1} & c_{1} \end{matrix}\right]=\left[\begin{matrix}1 & 1& 2 \end{matrix}\right]$
这样我们可以用大数乘法的方法，只用 $O\left(logn\right)$ 的时间完成矩阵乘法

3.复杂度估计 $O\left(logn\right)$ O(logN) time O(1) space linear algebraic algorithm (in python)

代码

解法一，

class Solution(object):
    def numTilings(self, N):
        """
        :type N: int
        :rtype: int
        35MS
        """
        if N == 1:
            return 1
        if N == 2:
            return 2
        dp = [1 for _ in range(N + 1)]
        dp[2] = 2
        for i in range(3, N + 1):
            dp[i] = (2 * dp[i - 1] + dp[i - 3]) % int(1e9 + 7)
        return dp[-1]

解法二，使用numpy库，直接使用矩阵乘法：

class Solution(object):
    def numTilings(self, N):
        """
        :type N: int
        :rtype: int
        95MS
        """
        import numpy as np
        if N == 1:
            return 1
        if N == 2:
            return 2
        if N % 2 == 1:
            k = (N - 2) // 2
            # a1,b1,c1
            start = np.array([1, 1, 2], dtype=np.int64)
        else:
            k = (N - 4) // 2
            # a2,b2,c2
            start = np.array([2, 3, 4], dtype=np.int64)
        A = np.array([[2, 3, 4], [1, 1, 2], [1, 1, 1]], dtype=np.int64)
        while k > 0:
            # 相当于转化为2进制
            if k % 2 == 1:
                start = np.dot(start, A) % 1000000007
            k //= 2
            A = A.dot(A) % 1000000007

        return int(np.dot(start, np.array([[2],[1],[1]], dtype=np.int64)) % 1000000007)