【算法】矩形覆盖

一、题目

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

二、解题思路

当$n>2$时，矩形覆盖最后一步覆盖的方法有两种：

1. 最后用了一个竖着的2*1小矩形进行覆盖，如图
   
2. 最后用了一个横着的2*1小矩形进行覆盖，如图
   如果最后用了一个横着的2*1小矩形进行覆盖，那么最后两个2*1的小矩形的覆盖情况必然如下：
   

所以，用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形相当于

1. 用n-1个2*1的小矩形无重叠地覆盖一个2*(n-1) 的大矩形最后用1个竖着的2*1小矩形进行覆盖
2. 用n-2个2*1的小矩形无重叠地覆盖一个2*(n-1) 的大矩形最后用2个横着的2*1小矩形进行覆盖

1.和2.两者之和，由此可得出以下递推公式：

$$f(n)=\{\begin{array}{ll}n,& n\le 2\\ f(n-1)+f(n-2),& n>2\end{array}$$

分析到这里不难发现本题的本质就是斐波那契数列问题。因此解题的方法也基本相同。

三、解题方法

代码实现使用 Python 2.7.3。

（一）递归

我们用递归算法就能够轻易实现以上式子，时间复杂度为$O(n^2)$。

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
	    if number <= 2:
            return number
        else:
            return self.rectCover(n-1) + self.rectCover(n-2)

虽然用递归算法来实现是很自然又很简单的想法，但是其时间复杂度太高，其时间复杂度高的原因是，重复计算了很多不必要的数值。我们用计算$f(5)$来说明问题：

可以看到，在计算$f(5)$时，$f(3)$重复计算了两遍。

（二）遍历

由于递归算法产生了很多不必要的重复计算，导致时间复杂度很高。为了降低时间复杂度，我们首先的想法就是避免重复计算。

我们考虑对于任意一个$N$，我们从第一项开始计算，并将所有的中间结果保存下来，这样在计算$f(n)$时，只需要通过查表直接获取$f(n-1)$和$f(n-2)$的值计算即可，时间复杂度减少为$O(n)$。

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        if number <= 2:
            return number
        else:
            array = [1, 2]
            for i in range(2, number):
                array.append(array[i-1]+array[i-2])
            return array[-1]

（三）矩阵乘法

实际上，遍历的方法还不是最优的，本题最优的解决方法的时间复杂度只需要$O(\log n)$。

$f(n)=f(n-1)+f(n-2)$是一个二阶递推数列，一定可以用矩阵乘法的形式表示，即状态矩阵为$2\times 2$的矩阵：
$$\left[\begin{array}{cc}f(n)& f(n-1)\end{array}\right]=\left[\begin{array}{cc}f(n-1)& f(n-2)\end{array}\right]\left[\begin{array}{cc}a& b\\ c& d\end{array}\right]$$可以解得$a=b=c=1,d=0$。再通过归纳法可得：

$$\begin{array}{rl}\left[\begin{array}{cc}f(n)& f(n-1)\end{array}\right]& =\left[\begin{array}{cc}f(n-1)& f(n-2)\end{array}\right]\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]\\ & =\left[\begin{array}{cc}f(n-2)& f(n-3)\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^2\\ & =\cdots \cdots \\ & =\left[\begin{array}{cc}f(2)& f(1)\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^{n-2}\\ & =\left[\begin{array}{cc}2& 1\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^{n-2}\end{array}$$这样，求斐波那契数列第N项的问题就变成了如何用最快的方法求一个矩阵N次方的问题。

求整数N次方的问题与求矩阵N次方的问题同理。为了表示方便，用求一个整数N次方的例子来说明。快速求$10^{11}$的过程如下：

1. 11的二进制形式为1011
2. $10^{11}=10^{1\times 8}\times 10^{0\times 4}\times 10^{1\times 2}\times 10^{1\times 1}$

在这个过程中，我们先求出$10^1$，然后根据$10^1$求出$10^2$，再根据$10^2$求出$10^4$，…，最后求出$10^8$。因此，11的二进制数形式总共多少位，就使用了几次乘法

然后把应该累乘的值相乘即可，即$10^8$、$10^2$、$10^1$应该累乘，因为8、2、1对应到11的二进制数中，相应位上是1；而$10^4$不应该累乘，因为4对应到11的二进制数中，相应位上是0。

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        if number <= 2:
            return number
        else:
            array = [[1, 1], [1, 0]]
            res = [[1, 0], [0, 1]]
            
            times = number - 2
            while times:
                if (times&1) != 0:
                    a = res[0][0]*array[0][0] + res[0][1]*array[1][0]
                    b = res[0][0]*array[0][1] + res[0][1]*array[1][1]
                    c = res[1][0]*array[0][0] + res[1][1]*array[1][0]
                    d = res[1][0]*array[0][1] + res[1][1]*array[1][1]

                    res[0][0], res[0][1], res[1][0], res[1][1] = a, b, c, d
                
                a = array[0][0]*array[0][0] + array[0][1]*array[1][0]
                b = array[0][0]*array[0][1] + array[0][1]*array[1][1]
                c = array[1][0]*array[0][0] + array[1][1]*array[1][0]
                d = array[1][0]*array[0][1] + array[1][1]*array[1][1]

                array[0][0], array[0][1], array[1][0], array[1][1] = a, b, c, d

                times = times >> 1
                
            return 2 * res[0][0] + res[1][0]