斐波那契数列、跳台阶、变态跳台阶、矩形覆盖

#include<iostream>
#include<math.h>
using namespace std;

//斐波那契数列
class Solution
{
public:
int Fibonacci1(int n)
{
/*
*第一种解法：递归————从上往下计算，重复计算太多，效率太低，不能满足时间要求
*/
if (n == 0)
return 0;
if (n == 1)
return 1;

return Fibonacci1(n - 1) + Fibonacci1(n - 2);
}

int Fibonacci2(int n)
{
/*
*第二种解法：从下往上计算，减少重复计算
*/
int n0 = 0, n1 = 1;
int ret;
if (n == 0)
ret = 0;
if (n == 1)
ret = 1;

for (int i = 2; i <= n; i++)
{
ret = n0 + n1;

n0 = n1;
n1 = ret;
}
return ret;
}
};

//扩展1：青蛙跳台阶————一次可以跳1级，也可以跳2级，求跳N级的跳法种数。
class Solution2
{
public:
int jumpFloor1(int n)
{
/*
*n=1：只有1种跳法；
*n=2：两种跳法；
*n>2：假设跳N级的跳法有f(n)种，
*         （1）第一次跳，跳1级，则剩下N-1级的跳法有f(n-1)种；
*         （2）第一次跳，跳2级，则剩下N-2级的跳法有f(n-2)种；
*     所以：f(n) = f(n-1) + f(n-2)。
*/
//if (n == 0 || n == 1)
if (n == 1)
return 1;
if (n == 2)
return 2;

return jumpFloor1(n - 1) + jumpFloor1(n - 2);
}

int jumpFloor2(int number) {

int n0 = 1, n1 = 2;
int ret;
if (number == 1)
ret = 1;
if (number == 2)
ret = 2;

for (int i = 3; i <= number; i++)
{
ret = n0 + n1;

n0 = n1;
n1 = ret;
}
return ret;
}

int jumpFloor3(int number) {
/*
*第3种解法：滚动数组
*/
int F[3] = { 0, 1, 2 };
if (number <= 2)
{
return F[number];
}
for (int i = 3; i <= number; i++)
{
F[0] = F[1];
F[1] = F[2];
F[2] = F[0] + F[1];
}
return F[2];

}
};

//扩展2：青蛙变态跳台阶————一次可以跳1级，也可以跳2级.....，也可以跳上N级台阶，求跳N级的跳法种数。
class Solution3
{
public:
int jumpFloorII(int number) {
/*
*第1种解法：递归————从顶往下计算
*     f(n) = f(0)+f(1)+f(2)+f(3)+......+f(n-2)+f(n-1) ———— 第一次跳n，第一次跳n-1......
*又   f(n-1) = f(0)+f(1)+f(2)+f(3)+......+f(n-2)
*所以 f(n) - f(n-1) = f(n-1) -----> f(n) = 2 * f(n-1)
*/

if (number == 1)
return 1;

return 2 * jumpFloorII(number - 1);
}

int jumpFloorII1(int number) {
/*
*第2种解法：从下往顶计算
*最后剩下0个台阶，暂且定为0，直接跳n个台阶上来，显然只有一种方法（也就是说，对于任何一个“N”，我们都可以直接跳“N”，所以我们每次循环首先自加1就行了）
*最后剩下1个台阶，那么共有（第n-1个台阶的方法数）种；
*最后剩下2个台阶，共有(第n-2个台阶的方法数)种；
*....
*最后剩下n-1个台阶，只有一种方法。
*累加上面每一种的方法，就是跳到第n阶台阶的总的跳法种数
*/
long long int arr[100] = { 0, 1 };      //限定最多跳100级
for (int i = 2; i < 100; i++)
{
int j = i - 1;
arr[i]++;      //直接跳跃到本身的"N"
while (j)
{
arr[i] = arr[i] + arr[j];
j--;
}
}
return arr[number];
}

int jumpFloorII2(int number) {
/*
*第3种解法：用数学归纳法证明f(n)=2^(n-1)。
*/
return pow(2, number - 1);
}

int jumpFloorII3(int number) {
/*
*第4种解法：滚动数组
*/
int F[2] = { 0, 1 };
if (number < 2)
return F[number];

for (int i = 2; i <= number; i++)
{
F[0] = F[1];
F[1] = 2 * F[0];
}
return F[1];
}
};

//扩展3：矩形覆盖————用number个2*1的矩形去覆盖更大的矩形（number*2），求总共的方法数。
class Solution4 {
public:
int rectCover(int number) {
if (number <= 0 || number == 1)
return 1;
if (number == 2)
return 2;

return rectCover(number - 1) + rectCover(number - 2);
}

int rectCover1(int number) {
if (number == 1)
return 1;
if (number == 2)
return 2;

int n1 = 1, n2 = 2, tmp = 0;
for (int i = 3; i <= number; i++)
{
tmp = n1 + n2;

n1 = n2;
n2 = tmp;
}
return tmp;
}
};

void main()
{
Solution4 s;
cout << s.rectCover1(5) << endl;
}