数楼梯 （洛谷）

题目

原文链接

题目描述

楼梯有 $N$ 阶，上楼可以一步上一阶，也可以一步上二阶。

编一个程序，计算共有多少种不同的走法。

输入格式

一个数字，楼梯数。

输出格式

输出走的方式总数。

样例 #1

样例输入 #1

4

样例输出 #1

5

提示

• 对于 $60\%$ 的数据，$N\le 50$；
• 对于 $100\%$ 的数据，$1\le N\le 5000$。

这道题改到后面我怕超出空间限制。不过题目上并没有限制空间大小，最终答案用了100多mb空间。

思路

很明显这题和斐波那契数列是一样的。具体思路是：
如果有n个台阶，第一步自由两个选择：走两个台阶或一个台阶。此时剩下n-2个台阶或者n-1个台阶。走法数就是n-2个台阶数和n-1个台阶数走法数相加。
而在n-2个台阶时走法数又是n-4和n-3个台阶走法数相加。
以此类推一直到只剩下2个和1个台阶。此时明显只有两种和一种走法。

这就是递归的基本原理，将大问题划分为一个小问题。
如果仅仅是这样那可以很快写出代码，就是平常的斐波那契代码

#include<iostream>
using namespace std;
long long int fun(int value){
	if(value==1||value==0)//如果只剩一个台阶的情况
		return 1;
	return fun(value-1)+fun(value-2);
}
int main(){
	int q;
	cin>>q;
	cout<<fun(q);
}

但是根据题目要求输入台阶数在5000以内，递归辉消耗大量时间。因此要对代码进行优化。
从上面图片上可以看到单纯使用递归会造成大量重复计算。例如在左边计算了n-3时，右边也有n-3的情况。这样就会造成重复计算，这些计算会随输入的台阶数重复越来越多。因此优化可以在这方面优化。
具体的方法就是通过存储计算过的台阶数来保证下次遇到一样的台阶数时不再进行重复运算。存储的方法可以通过数组存储
以下是具体代码：

#include<iostream>
using namespace std;
long long int ans[10000];				//存储数组
int len;								//当前存储的个数
long long int fun(int value){
	if(value<=len)						//如果该数已经计算就直接返回不再计算
		return ans[value];
	ans[value]=fun(value-1)+fun(value-2);//将新计算的数存储起来
	len++;								//当前存储个数加1
	return ans[value];
	
}
int main(){
	ans[1]=1;
	ans[2]=2;
	len=2;
	int q;
	cin>>q;
	if(q==0){						//注意台阶数为0的情况			
	cout<<0;
	return 0;
	}
	fun(q);
	cout<<ans[q];
}

这时时间问题已经解决，但是c++中long long int类型在无法存储斐波那契数列较后的数。因为斐波那契增长太快了。在第500个斐波那契数时，长度是105，大小为

225591516161936330872512695036072072046011324913758190588638866418474627738686883405015987052796968498626

因此这里要用到高精度存储和计算。这也是空间用了这么大原因。
高精度概括来说就是通过使用数组存储一个数，数组每一个元素存储一位数。然后通过算式运算。
整体代码无需大改，只要需要在数据存储和相加时修该即可。

最终代码

#include<iostream>
using namespace std;
typedef struct {
    char v[500];//使用char类型，比使用int更节省空间
    int len;
}value;		//高精度数定义

value pluss(value a,value b){//高精度加法函数定义
    value ans;
    bool flag=false;
    int i=0;
    for(;i<a.len||i<b.len;i++){
        if(i<a.len&&i<b.len){
            ans.v[i]=(a.v[i]+b.v[i]+flag-2*'0')%10+'0';
            flag=(a.v[i]+flag+b.v[i]-2*'0')/10;
        }
        else if(i<b.len){
            ans.v[i]=(b.v[i]+flag-'0')%10+'0';
            flag=(b.v[i]+flag-'0')/10;
        }
        else if(i<a.len){
            ans.v[i]=(a.v[i]+flag-'0')%10+'0';
            flag=(a.v[i]+flag-'0')/10;
        }
    }
    if(flag){
        ans.v[i]=flag+'0';
        i++;
    }
    ans.len=i;
    return ans;
}

value an[5001];  //存储已经计算了的数据
int n;         //当前计算了的数数量
value fun(int a){//递归计算
    if(a<=n)
        return an[a];
    an[a]=pluss(fun(a-1),fun(a-2));
    n++;
    return an[a];
}


int main(){
    an[1].len=1;
    an[1].v[0]='1';
    an[2].len=1;
    an[2].v[0]='2';  //预先定义基本的数
    n=2;             //定义了2个
    int q;
    cin>>q;
    if(q==0){        //台阶为0情况
        cout<<0;
        return 0;}
    value anss=fun(q);
    for(int i=anss.len-1;i>=0;i--){  //按位输出。此处存储方式是先个位再十位，因此要反着来
        cout<<anss.v[i];
    }
}