迷宮回溯和八皇后問題

遞歸的概念

簡單的說:遞歸就是方法本身調用本身，每次調用同時傳入不一樣的變量，遞歸有助於編程者解決複雜的問題，同時可讓代碼變得簡潔

package recusion;

public class RecursionTest {

    public static void main(String[] args) {
        test(5);
        int i = factorial(5);
        System.out.println(i);
    }
    //打印問題
    //當程序執行到一個方法時，就會開闢一個獨立的棧空間
    public static void test(int n) {
        if(n>2) {
            test(n-1);
        }
        System.out.print("n="+n+" ");//n=2 n=3 n=4 n=5 
    }
    //階乘問題
    public static int factorial(int n) {
        if( n == 1) {
            return 1;
        }else {
            return factorial(n-1)*n;
        }
    }
}

遞歸須要遵照的重要規則

1.執行一個方法時，就建立一個新的受保護的獨立空間(棧空間)

2.方法的局部變量是獨立的，不會相互影響,若是方法中使用額是引用類型的變量，就會共享該引用類型的數據

3.遞歸必須向退出遞歸的條件逼近，不然就是無限遞歸，

4.當一個方法執行完畢，或者遇到return，就會返回，遵照誰調用，就將結果返回給誰，同時當方法執行完畢或者返回時，該方法也就執行完畢(若是一個棧的代碼執行完畢了就會返回給調用者)

迷宮回溯問題

package recusion;

import java.util.ArrayList;
import java.util.List;

public class MiGong {

    public static void main(String[] args) {
        //先建立一個二維數組，模擬迷宮
        //地圖
        //map[0][0]
        
        List<Integer> ls = new ArrayList<Integer>();
        
        int[][] map = new int[8][7];
        //使用1表示牆
        //上下所有置爲1，用來做爲迷宮的牆
        for(int i=0; i<7;i++) {
            map[0][i]=1;
            map[7][i]=1;
        }
        for(int i=0;i<8;i++) {
            map[i][0]=1;
            map[i][6]=1;
        }
        //設置擋板
        map[3][1]=1;
        map[3][2]=1;
//      for(int i=0;i<8;i++) {
//          for(int j=0;j<7;j++) {
//              System.out.print(map[i][j]+" ");
//          }
//          System.out.println();
//      }
        System.out.println("========================");
        setWay(map,1,1);
        //輸出新的地圖
        for(int i=0;i<8;i++) {
            for(int j=0;j<7;j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

    }

    //使用遞歸回溯來歸小球找路
    //1.map 表示地圖
    //2.i,j表示從地圖的那個位置開始出發
    //3.若是小球能到map[6][5]位置，則說明通路找到
    //4.約定:當map[i][j]爲0表示該定沒有走過  當爲1表示牆  爲2表示通路能夠走；3表示改點已經走過，可是走不通
    //5.在走迷宮時，須要肯定一個策略 下 ->右 ->上->左，若是改點走不通，在回溯
    public static boolean setWay(int[][] map,int i,int j) {
        if(map[6][5] == 2) {//通路已經找到
            return true;
        }else {
            if(map[i][j] == 0) {//若是當前這個點尚未走過
                //按照策略 下 ->右 ->上->左 走
                map[i][j] = 2;//假定改點能夠走通
                if(setWay(map,i+1,j)) {//向下走
                    return true;
                }else if(setWay(map,i,j+1)) {
                    return true;
                }else if(setWay(map,i-1,j)) {
                    return true;
                }else if(setWay(map,i,j-1)) {
                    return true;
                }else {
                    map[i][j]=3;
                    return false;
                }
            }else {
                return false;
            }
        }
    }

}

8皇后問題

八皇后問題是一個以國際象棋爲背景的問題：如何可以在 8×8 的國際象棋棋盤上放置八個皇后，使得任何一個皇后都沒法直接吃掉其餘的皇后？爲了達到此目的，任兩個皇后都不能處於同一條橫行、縱行或斜線上。

八皇后問題思路分析

1. 第一個皇后先放第一行第一列
2. 第二個皇后放在第二行第一列，而後判斷是否相互攻擊,若是相互攻擊，就繼續放在第二列，第三列，依次把全部列都放完，找到一個合適
3. 繼續第三個皇后，仍是第一列，第二列....直到第8個皇后也能放在一個不衝突的位置，算是找到了一個正確解
4. 當獲得一個正確解，在棧回退到上一個棧是，就會開始回溯，即將第一個皇后，放到第一列的全部正確解，所有獲得
5. 而後回頭繼續第一個皇后放第二列，後面繼續循環執行1,2,3,4步驟

arr[i]=val ,val表示第i+1個皇后，放在第i+1行的第val+1列

package recusion;

import java.lang.reflect.Array;

public class Queue8 {
    int max = 8;
    int[] array = new int[max];
    static int count=0;
    public static void main(String[] args) {
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println(count);
        
    }
    //編寫一個方法，放置第n個皇后
    private void check(int n) {
        if(n == max) {
            print();
            return;
        }
        //依次放入皇后，判斷是否衝突
        for(int i=0;i<max;i++) {
            array[n]=i;
            //判斷當放置第n個皇后到i列時，是否衝突
            if(judge(n)) {//不衝突
                //接着放n+1個皇后，即開始遞歸
                check(n+1);
            }
            
            //若是衝突，就繼續執行array[n]=i;即將第n個皇后，放置在本行的後移的一個位置
        }
    }
    //查看當咱們放置第n個皇后，就去檢測該皇后是否和前面已經擺放的皇后衝突
    //array[i]==array[n]表示判斷第n個皇后是否和前面的n-1個皇后在同一列
    //Math.abs(n-i)==Math.abs(array[n]-array[i]))表示判斷第n個皇后是否和第i皇后是否在同一個斜線
    private boolean judge(int n) {
        for(int i=0;i<n;i++) {
            if(array[i]==array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])) {
                return false;
            }
        }
        return true;
    }
    
    //寫一個方法，能夠將皇后擺放的位置輸出
    private void print() {
        count++;
        for(int i=0;i<array.length;i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}