剑指offer：6. 递归和循环（斐波那契、跳台阶、变态跳台阶、矩阵覆盖）

6. 递归和循环专题

题目描述

剑指offer上有四道关于递归和循环相关的题目，基本可以覆盖到各个考点。直接把四道题一并总结。
斐波那契数列
跳台阶
变态跳台阶
矩阵覆盖

思路：归纳法：归纳出f(n)与f(n-1)的关系。例如青蛙变态跳台阶问题：

/**
 * 思路：
 *  n = 1时，f(1)  = 1;
 *  n = 2时，f(2) = f(2-1) + f(2-2) = 2;
 *  n = 3时，f(3) = f(3-1) + f(3-2) + f(3-3);
 *  n = n-1时，f(n-1) = ;
 *  n = n时，f(n) = f(n-1) + f(n-2) + ...+ f(n-(n-1)) + f(n-n);
 *  简化：
 *  f(n-1) = f(0) + f(1) + f(2) + ... + f(n-1-1);
 *  f(n) = f(0) + f(1) + f(2) + ... + f(n-1);
 *  因此 f(n) = 2(f(n-1));
 *
 *  说明：
 * 1）这里的f(n) 代表的是n个台阶有一次1,2,...n阶的 跳法数。
 * 2）n = 1时，只有1种跳法，f(1) = 1
 * 3) n = 2时，会有两个跳得方式，一次1阶或者2阶，这回归到了问题（1） ，f(2) = f(2-1) + f(2-2)
 * 4) n = 3时，会有三种跳得方式，1阶、2阶、3阶，
 *     那么就是第一次跳出1阶后面剩下：f(3-1);第一次跳出2阶，剩下f(3-2)；第一次3阶，那么剩下f(3-3)
 *     因此结论是f(3) = f(3-1)+f(3-2)+f(3-3)
 * 5) n = n时，会有n中跳的方式，1阶、2阶...n阶，得出结论：
 *     f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)
 * 6) 由以上已经是一种结论，但是为了简单，我们可以继续简化：
 *     f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)
 *     f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)
 *     可以得出：
 *     f(n) = 2*f(n-1)
 * 7) 得出最终结论,在n阶台阶，一次有1、2、...n阶的跳的方式时，总得跳法为：
 *             | 1       ,(n=0 )
 * f(n) =     | 1       ,(n=1 )
 *           | 2*f(n-1),(n>=2)
 */

归纳出递推的关系，代码就比较简单了。
Java实现：

/**
 * @Classname JumpFloorII
 * @Description 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。
 *               求该青蛙跳上一个n级的台阶总共有多少种跳法。
 * @Date 2019/7/4 9:09
 * @Created by 超
 */
public class JumpFloorII {
//普通跳台阶
    public int JumpFloor(int n) {
        if (n == 0) {
            return 0;
        } else  if (n == 1 || n == 2) {
            return n;
        } else {
            int num = JumpFloor(n - 1) + JumpFloor(n - 2);
            System.out.println(num);
            return 0;
        }
    }

//变态跳台阶
    public int JumpFloorI(int n) {
        if (n == 0) {
            return 0;
        } else  if (n == 1 || n == 2) {
            return n;
        } else {
            int num = 2 * JumpFloorI(n - 1);
            return num;
        }

    }

    public static void main(String[] args) {
        int n = 3;
        JumpFloorII solve = new JumpFloorII();
        //solve.JumpFloor(n);
        System.out.println(solve.JumpFloorI(n));
    }
}

斐波那契数列

循环和递归两种方法

import javax.sound.midi.SysexMessage;

/**
 * @Classname FibonacciSequence
 * @Description 要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
 * @Date 2019/7/1 15:09
 * @Created by 超
 */
public class FibonacciSequence {

    public int Fibonacci(int n) {
        if (n == 0) {
            System.out.print(0);
        }
        else if (n == 1) {
            System.out.print(1);
        }
        else {
            System.out.print(Fibonacci(n-1) + Fibonacci(n-2));
        }
        return n;
    }

    public int Fibonacci1(int n) {
        int a = 0, b = 1, c = 1;
        if (n == 0) {
            return 0;
        } else if (n == 1 ||n == 2) {
            return 1;
        } else {
            for (int i = 3; i <= n; i++) {
                a = b+c;
                b = c;
                c = a;
            }
            return c;
        }
    }

    public static void main(String[] args) {
        int n = 30;
        FibonacciSequence solution = new FibonacciSequence();
        solution.Fibonacci(n);
    }
}

矩阵覆盖

依旧是斐波那契数列
2*n的大矩形，和n个2*1的小矩形
其中target*2为大矩阵的大小
有以下几种情形：

1. target <= 0 大矩形为<= 2*0,直接return 1；
2. target = 1大矩形为2*1，只有一种摆放方法，return1；
3. target = 2 大矩形为2*2，有两种摆放方法，return2；
4. target = n 分为两步考虑：
   第一次摆放一块 2*1 的小矩阵，则摆放方法总共为f(target - 1)
   
   第一次摆放一块1*2的小矩阵，则摆放方法总共为f(target-2)
   因为，摆放了一块1*2的小矩阵（用√√表示），对应下方的1*2（用××表示）摆放方法就确定了，所以为f(targte-2)
   

代码：

/**
 * @Classname RectCover
 * @Description 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。
 * 请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
 * @Date 2019/7/4 10:05
 * @Created by 超
 */

/**
 * 分析：
 * if n=1，f(n) = f(1) + f(0) = 1;
 * if n=2, f(n) = f(2) + f(1) + f(0) = 2
 * if n=3, f(3) =
 */
public class RectCover {
    public int RecCover(int target) {
        if (target == 0) {
            return 0;
        } else if (target == 1 || target == 2) {
            return target;
        } else {
            int num = 2 * RecCover(target-1);
            return num;
        }
    }

    public static void main(String[] args) {
        RectCover rectCover = new RectCover();
        System.out.println(rectCover.RecCover(2));
    }
}

不足之处欢迎批评讨论！