劍指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));
    }
}

不足之處歡迎批評討論！