矩形覆盖问题

问题描述：

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

解法一：

设 2*n 的大矩形有F(n)种被覆盖方法。

1）当n = 0时，大矩形为空，显然F(0) = 0；

2）当n = 1时，大矩形与小矩形规格相同，F(1) = 1；

3）当n = 2时，使用2个小矩形可覆盖大矩形，但横竖摆放各有1种方法，故F(2) = 2；

4）当n > 2时，覆盖方法可分为两大类（见下图）：1.先用 2*1 的小矩形覆盖大矩形的第一列，其后 n-1 列则有 F(n - 1)种覆盖方法；2.先用两个 2*1 的小矩形覆盖大矩形的前两列，其后 n-2 列共有F(n - 2)种覆盖方法， 故有递推公式 F(n) = F(n - 1) + F(n - 2)。

由此可见，An = F(n) 跟数学上的斐波拉契数列类似(不同点：严格定义的斐波拉契数列F(2) = F(0) + F(1) = 1)，求F(n)也就是求类斐波拉契数列的第n项的值。



落实到代码上，有2种实现方法：1)迭代实现，2)递归实现。

迭代实现：

/** 用迭代方法计算斐波拉契数列 */
public int RectCover(int n) {
if (n <= 2)
return n;

int index = 3;    // 从第3项开始需要递推计算F(n)
int value1 = 1;   // F(n - 2)
int value2 = 2;   // F(n - 1)
do {
int tmp = value2;
value2 = value1 + value2;   // 计算F(n) = F(n - 2) + F(n - 1)
value1 = tmp;
index++;
}
while (index <= n);

return value2;
}

递归实现：

/** 递归实现 */
public int RectCover(int n) {
if (n <= 2)  // 递归终止条件
return n;

int count = RectCover(n - 1) + RectCover(n - 2);
return count;
}

该实现时间复杂度较高，因为存在重复计算问题。举例来说，为了计算F(5)，由于F(5) = F(4) + F(3), 程序需要递归计算F(4)和F(3)。而F(3) = F(2) + F(1), F(4) = F(3) + F(2), 为了计算F(3)和F(4), 程序需要递归计算F(2)各一次，也就是是说F(2)被重复计算了。当n的规模越大，F(m)，m < n 被重复计算的次数会越多。

为了解决重复计算问题，可以将递归中间计算结果F(m)暂存在散列表中，此后递归若再次遇到F(m)，则从散列表中将计算结果直接取出即可，不再进行递归。

代码如下：

import java.util.*;

public class Solution {

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
/** 递归实现 */
public int RectCover(int n) {
if (n <= 2)  // 递归终止条件
return n;

int res = 0;
// 散列表未存有计算结果，递归计算并存入散列表
if (!map.containsKey(n)) {
res = RectCover(n- 1) + RectCover(n- 2);
map.put(n, res);
// 散列表存有计算结果，从散列表中取出
} else {
res = map.get(n);
}
return res;
}
}

解法二：

转化成排列组合问题。如图所示，当大矩形被小矩形完全覆盖后，大矩形内存在2种类型的区块：1、由1个竖向小矩形组成的小块，称为“A块”；2.由2个横向小矩形组合而成的大块，称为”B块”。



大矩形的“A块”和“B块”可以有不同数量组合(减少1个”B块”会相应地增加2个“A块”)和多种排列方式。大矩形的“A块”和”B块”的不同的数量划分情况下不同的排列方式，均对应不同的矩形覆盖方法。因此，问题可被转换为排列组合问题，矩形覆盖方法数等于“A块”、“B块”所有数量划分情形下的所有排列方式数量之和。

具体实现见代码：

public int RectCover(int n) {
if (n <= 0)
return 0; // 特殊情形

int n1 = n / 2; // “B块”最大个数
int n2 = n % 2; // “A块”最少个数

int result = 0;
/**
* 每次减少1个“B块”，相应增加2个“A块”，并计算排列种数
*/
for (int i = n1; i >= 0; i--) {
int sum = i + n2 + (n1 - i) * 2; // 块总数
result += comb(sum, i);
}

return result;
}

// 计算组合数
private int comb(int m, int n) {
n = n < (m - n) ? n : (m - n);
int res = 1;
for (int i = 1; i <= n; i++)
// 这个用到了组合数的性质c(8,4)=8/1*7/2*6/3*5/4=c(8,3)*5/4
res = res * m-- / i;
return res;
}