动态规划

题目：
有一座高度是10级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶。要求用程序来求出一共有多少种走法。

分析：斐波那切数列(可以这么想，假设10个台阶，想要到达第10个台阶有两种可能，①从第9个台阶向上走1个台阶，②从第8个台阶向上走两个台阶。那么num（10）=num（9）+num（8)）
n=1······>num=1
n=2······>num=2
n=3······>num=1+2=3
…
n=n······>num=num(n-1)+num(n-2)
通过以上分析最先想到的是递归，代码如下

public class DongtaiGuihua {
    public static void main(String[] args) {
        System.out.println(getClimbWays(10));
    }
    public static int getClimbWays(int n){
        if(n<1) return 0;
        if(n==1) return 1;
        if(n==2) return 2;
        return getClimbWays(n-1)+getClimbWays(n-2);
    }
}

缺点：时间复杂度过高为O（n^2），图中节点的个数即为近似时间复杂度

想解决上述问题，可采取的方法之一是利用哈希表，存储已知结果，避免重复计算

public static int getClimbWays1(int n){
        HashMap<Integer,Integer> map=new HashMap<>();
        if(n<1) return 0;
        if(n==1) return 1;
        if(n==2) return 2;
        if(map.containsKey(n)){
            return map.get(n);
        }else{
            int value=getClimbWays1(n-1)+getClimbWays1(n-2);
            map.put(n,value);
            return value;
        }
     }

此时时间复杂度O（n），空间复杂度O（n）
要想把空间复杂度降低，就要逆向思考，运用动态规划方法

public static int getClimbWays2(int n){
        int num=0;
        if(n<1) num=0;
        if(n==1) num=1;
        if(n==2) num=2;
        if(n>2){
            int a=1,b=2;
            for(int i=3;i<=n;i++){
                num=a+b;
                a=b;
                b=num;
            }
        }
        return num;
    }