JAVA 探索二维数组中的八皇后与五子棋

八皇后

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法（92种）

因为八皇后数量较多，不好画图展示，先来解释五皇后问题，其原理都是一样的，我一行一行解决皇后的摆放问题‘’

首先将每一行的可能都画出来，第一行五个；

到第二行时，第一行的每一个都有可能是一种解法，所以都要去遍历；

例如：第一行的第一个有三种，所以第二行是第一个的情况下有三种；

然后继续向下递，第二行的第一个只有一种，继续向下，第四行、第五行也只有一种；

接下来会跑到第六行，这会发生角标越界，所以不能无限制的往下递，故递归的时候中间还有个结束 end；

当已经第一种解法结束的时候，我们开始归；

归到有多种可能的时候选择另外一种可能继续递；

然后依次类推。（因为每一种都会有一个for循环，嵌套太多，所以不能用迭代，应该用递归。）

 在理解了思想后我们开始写代码。因为摆放皇后是从上向下开始摆放的，所以在8个方位上只有4个有效，有为因为在每一行摆放皇后时都会将这一行棋盘（备份的棋盘）都置为0（null），故总共要考虑3个方位。

class EightQueen{
    //n皇后如何处理？n>=4
    public static int count=0;
    public static int n;
    public static void main(String[] args){
        n=8;
        int[][] board=new int[n][n];
        //0就是空 1就是皇后
        eightQueen(board,0);
    }
    //解决board在第level层的八皇后问题 level 0~7
    public static void eightQueen(int[][] board,int level){
        if(level==n){   //如果递归到了第9行 则当前是一个解
            count++;
            System.out.printf("这是第%d个解:\n",count);
            for(int i=0;i<board.length;i++){
                for(int j=0;j<board[i].length;j++){
                    System.out.print(board[i][j]+" ");
                }
                System.out.println();
            }
        }else{
            //1.先做一份上一个情况的备份
            int[][] newBoard=new int[n][n];
            for(int i=0;i<board.length;i++){
                for(int j=0;j<board[i].length;j++){
                    newBoard[i][j]=board[i][j];
                }
            }
            //2.遍历当前行 找到所有可能的解
            for(int col=0;col<n;col++){
                //3.判断当前位置是否可以放皇后
                //  3.1 如果可以 则继续往下一行去寻找
                //  3.2 如果不行 则继续判断一下个位置
                if(isNoDanger(newBoard,level,col)){
                    //在赋值皇后之前 先当前行清空
                    for(int c=0;c<n;c++){
                        newBoard[level][c]=0;
                    }
                    newBoard[level][col]=1; //当前给皇后
                    eightQueen(newBoard,level+1);//接着下一行找
                }
            }
        }
    }
    //判断board当中 x y的位置上是否可以放置一个皇后
    public static boolean isNoDanger(int[][] board,int x,int y){
        //正上
        for(int r=x-1;r>=0;r--){
            if(board[r][y]==1){
                return false;
            }
        }
        //左上
        for(int r=x-1,c=y-1;r>=0&&c>=0;r--,c--){
            if(board[r][c]==1){
                return false;
            }
        }
        //右上
        for(int r=x-1,c=y+1;r>=0&&c<n;r--,c++){
            if(board[r][c]==1){
                return false;
            }
        }
        return true;
    }
}

        中间结果就省略了。                                                

---

五子棋

    /*
    五子棋 黑白棋 谁先连成5个子 谁就赢
    棋盘 我们用什么去表示棋盘
    +++++++
    +++++++
    +++++++
    那也就是说我们需要创建一个String的二维数组来表示棋盘
    如何下棋呢？
    目前我们的程序是控制台程序，不能说是用点击的方式进行下棋
    只能是输入棋子的坐标进行下棋
    输入 1,1 指的就是在(0,0)处下一个棋子
    
    初始化棋盘 initBoard()
    打印棋盘   printBoard()
    开始游戏   startGame()
    下棋(黑白) putDownChess()
    判断输赢   isGameOver()

    判断哪种棋子赢   chessColour()
    上述方法都会去调用棋盘board数据
    如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
    我们可以将board数据定义为全局变量 任何函数都可以访问的变量
    全局变量定义在函数的外面 类的里面 必须public static开头
    */

import java.util.*;
class Demo05_15{
    //全局变量 棋盘 方便函数直接调用 而不需要依次传参
    public static String[][] board; //定义为是15*15的棋盘
    public static String BLACK_CHESS="O";   //黑棋
    public static String WHITE_CHESS="X";   //白棋
    public static Scanner scanner=new Scanner(System.in);
    public static int player = 0;
    public static void main(String[] args){
        //1.初始化棋盘
        initBoard();
        //2.打印棋盘
        printBoard();
        //3.开始游戏
        startGame();
        //4.判断哪种棋子赢
        chessColour();
    }
    public static void startGame(){
        /*
        黑方 白方 轮流 下棋 
        */
        //player 偶数 黑 ；奇数 白
        while(true){
            if(player%2==0){    //黑方下棋
                System.out.print(">>>请黑方下棋:");
                if(!putDownChess(BLACK_CHESS)){
                    continue;
                }
            }else{              //白方下棋
                System.out.print(">>>请白方下棋:");
                if(!putDownChess(WHITE_CHESS)){
                    continue;
                }
            }
            if(isGameOver()){
                break;
            }
            player++;
        }
    }
public static boolean isGameOver(){
        for(int i = 0;i<board.length;i++){
            for(int j= 0;j<board[i].length;j++){
                if(!board[i][j].equals("+")){
                    if(j<board[i].length-4){//向右
                    boolean flag=true;
                    for(int c = j+1;c<j+5;c++){
                        if(board[i][j]!= board[i][c]){
                           flag=false;
                            break; 
                        }
                    }
                    if(flag){
                        System.out.println("游戏结束");
                        return true;
                    }
                }
                if(i<board.length-4){//向下
                    boolean flag=true;
                    for(int c = i+1;c<i+5;c++){
                        if(board[i][j]!= board[c][j]){
                           flag=false;
                            break; 
                        }
                    }
                    if(flag){
                        System.out.println("游戏结束");
                        return true;
                    }
                }
                if(j<board[i].length-4 && i<board.length-4){//向右下
                    boolean flag=true;
                    for(int c = j+1,d = i+1;c<j+5;c++,d++){
                        if(board[i][j]!= board[d][c]){
                           flag=false;
                            break; 
                        }
                    }
                    if(flag){
                        System.out.println("游戏结束");
                        return true;
                    }
                }
                if(i>3 && j<board.length-4){//向右上
                    boolean flag=true;
                    for(int c = i-1,d = j+1;d<j+5;c--,d++){
                        if(board[i][j]!= board[c][d]){
                           flag=false;
                            break; 
                        }
                    }
                    if(flag){
                        System.out.println("游戏结束");
                        return true;
                    }
                }
            }
        }
                }
        return false;
    }
    public static void chessColour(){
        if(player==15*15){
            System.out.println("游戏结束，和棋");
        }
        if(player % 2==0){
            System.out.println("游戏结束,黑棋获胜");
        }else{
            System.out.println("游戏结束,白棋获胜");
        }
    } 
    public static boolean putDownChess(String chess){
        //用户输入的 (1,1) -> (0,0)
        //1 B
        int x=scanner.nextInt()-1;
        int y=scanner.next().charAt(0)-'A';
        if(!board[x][y].equals("+")){
            System.out.println(">>>此处已有棋子，请重新下棋");
            //另外一种处理方式 就是讲player定义为全局 此处player--即可
            return false;//意味着下棋不成功
        }
        board[x][y]=chess;
        printBoard();
        return true;    //意味着下棋成功
    }
    public static void printBoard(){
        System.out.print("   ");
        for(int i=0;i<=14;i++){
            System.out.print((char)('A'+i)+" ");
        }
        System.out.println();
        for(int i=0;i<board.length;i++){
            System.out.printf("%2d ",i+1);
            for(int j=0;j<board[i].length;j++){
               System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void initBoard(){
        board=new String[15][15];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                board[i][j]="+";
            }
        }
    }
}