题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
解题思路：青蛙每一次跳跃只有两种选择:一是再跳1级阶梯到达第n级阶梯,此时小青蛙处于第n-1级阶梯;或者再跳2级阶梯到达第n级阶梯,此时小青蛙处于n-2级阶梯于是,n级阶梯的跳法总是依赖于前n-1级阶梯的跳法总数f(n-1)和前n-2级阶梯的跳法总数f(n-2).因为只有两种可能性,所以,f(n)=f(n-1)+f(n-2);
递推公式f(n)=f(n-1)+f(n-2)很熟悉,就是斐波那契数列求和（Sn=2a(n)+a(n-1)-1）。
递归求法： 
public class JumpFloor {
    public int JumpSolution1(int n) {
        if (n < 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        return JumpSolution1(n - 1) + JumpSolution1(n - 2);
    }
}
递归求法简单易懂，但是会有重复的计算，占用内存空间。
备忘录算法（记忆搜索）：
另一种备忘录算法，备忘录方法是动态规划方法的变形。与动态规划算法不同的是，备忘录方法的递归方式是自顶向下的，而动态规划算法则是自底向上的。计算采用递归方式，值计算出来之后将其保存起来以备它用。
可以事先准备一个Hashmap,每计算出一个结果之后，可以将结果放入哈希表中，下次进行递归计算的时候，现在map中查询这个递归是否已经计算过了。如果已经计算过了，就把值直接拿出来用即可。 
import java.util.HashMap;
public class JumpFloor2 {
    public static int JumpSolution2(int n, HashMap<Integer, Integer> map){
        if (n < 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        if (map.containsKey(n)){
            return map.get(n);
        }else {
            int value = JumpSolution2(n - 1, map) + JumpSolution2(n - 2, map);
            map.put(n, value);
            return value;
        }
    }

斐波那契函数方法： 

public class Solution {
    public int JumpFloor(int target) {
 
        int a=1,b=2,c=3;
        if(target==1 || target==2)
            return target;
        for(int i=2;i<target;i++)
            {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}
动态规划： 
public int climbStairs3(int n) {
     if ( n == 1) {
        return 1;
    }
    int[] dp = new int[n + 1];
    dp[1] = 1;
    dp[2] = 2;
    for (int i = 3; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i -2];
    }
    return dp[n];
}