---

套路

• 共同特点是当前值可以由前一个或前两个或前面的某几个特定的位置的值推导得到。

---

注意点

• 如果会出现栈溢出（StackOverflow），那么将递归转为正向循环求解。总之，推荐正向循环求解，正向求解更优。所有的递归都可以用正向循环去实现。
• 递归是必会，而且首先要考虑的，代码量最小的，最优解。

---

目录

• 跳台阶
• 变态跳台阶
• 矩形覆盖
• 斐波那契数列
• 机器人的运动范围

---

跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

public int JumpFloor(int target) {
    if (target <= 0) return 0;
    if (target == 1 || target == 2) {
        return target;
    }
    return JumpFloor(target - 1) + JumpFloor(target - 2);
}

---

变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

• 思路分析：

f1 = 1
f2 = f1 + 1 = f1 * 2
f3 = f2 + f1 + 1 = f2 * 2
f4 = f3 + f2 + f1 + 1 = f3 * 2
得到当 n > 1 时，fn = f(n - 1) * 2

public int JumpFloorII(int target) {
    if (target <= 0) return 0;
    int ans = 1;
    for (int i = 1; i < target; i++) {
        ans *= 2;
    }
    return ans;
}

矩形覆盖

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

• 最优解：递归调用 f(n) = f(n-1) + f(n-2)，改进为正向循环求解

public int RectCover(int target) {
    if (target <= 0) return 0;
    if (target == 1) return 1;
    if (target == 2) return 2;
    return RectCover(n - 1) + RectCover(n - 2);
}

public int RectCover(int target) {
    if (target <= 0) return 0;
    int a = 1, b = 2;
    for (int i = 1; i < target; i++) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return a;
}

---

斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39

public int Fibonacci(int n) {
    if (n <= 0) return 0;
    int a = 1, b = 1;
    for (int i = 1; i < n; i++) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return a;
}

---

机器人的运动范围

题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

public int movingCount(int threshold, int rows, int cols) {
    int[][] flag = new int[rows][cols];
    return helper(threshold, flag, 0, 0, rows, cols);
}

private int helper(int key, int[][] flag, 
                   int i, int j, int rows, int cols) {
    if (i > rows - 1 || j > cols - 1 
        || flag[i][j] == 1 || numSum(i) + numSum(j) > key) {
        return 0;
    }
    flag[i][j] = 1;
    return helper(key, flag, i + 1, j, rows, cols)  + helper(key, flag, i, j + 1, rows, cols) + 1;
}

private int numSum(int i) {
    int sum = 0;
    do {
        sum += i % 10;
    } while ((i /= 10) > 0);
    return sum;
}

---