用JAVA语言写概率算法求解八皇后问题。要求如下步骤:1.有算法思路，2.代码思路，3.伪代码 ，4.代码实现，并且代码中要有重点注释。

算法思路：

八皇后问题是在 8 × 8 的棋盘上放置 8 个皇后，使其不能互相攻击，即任意两个皇后不在同一行、同一列或同一斜线上。我们可以使用概率算法求解八皇后问题，具体步骤如下：

1.初始化一个 8 * 8 的二维数组，表示棋盘。

2.随机选取一个格子（行、列），将皇后放置在该格子上。

3.计算当前棋盘上皇后的冲突数（即互相攻击的皇后对数）。

4.如果冲突数为 0，则表示已经找到了一组解，直接输出结果并停止算法。

5.如果冲突数不为 0，则从当前格子移动到下一个格子，再将皇后放置在该格子上，重复步骤 3。

6.如果所有格子都尝试过了，仍然没有找到解，则回溯到上一个格子，再尝试下一个格子，重复步骤 3。

代码思路：

1.定义一个 8 * 8 的二维数组 chessboard 表示棋盘，初始值都为 0。

2.定义一个一维数组 queenPos 表示每一行皇后的位置，初始值都为 -1。

3.定义一个函数 isConflict 判断两个皇后是否冲突，如果在同一行、同一列或同一斜线上则返回 true，否则返回 false。

4.定义一个函数 printSolution 输出一组解。

5.定义一个函数 backtrack 递归求解八皇后问题。

6.在 backtrack 函数中，首先检查是否已经找到一组解，如果是则直接返回。

7.然后从当前行开始，依次尝试每个格子，如果该格子不冲突，则将皇后放置在该格子上，并递归调用 backtrack 函数。

8.如果当前行所有格子都尝试过了，仍然没有找到解，则回溯到上一行，继续尝试下一个格子。

9.在主函数中调用 backtrack 函数求解八皇后问题。

伪代码：

chessboard[8][8] = {{0}} // 初始化棋盘
queenPos[8] = {-1} // 初始化每一行皇后的位置
solutionFound = false // 是否已经找到一组解

function isConflict(row1, col1, row2, col2):
    if row1 == row2 or col1 == col2 or abs(row1 - row2) == abs(col1 - col2):
        return true
    return false

function printSolution():
    for i from 0 to 7:
        for j from 0 to 7:
            if queenPos[i] == j:
                print "Q",
            else:
                print ".",
        print

function backtrack(row):
    if solutionFound:
        return
    if row == 8:
        printSolution()
        solutionFound = true
        return
    for col from 0 to 7:
        conflict = false
        for i from 0 to row - 1:
            if isConflict(i, queenPos[i], row, col):
                conflict = true
                break
        if not conflict:
            queenPos[row] = col
            chessboard[row][col] = 1
            backtrack(row + 1)
            chessboard[row][col] = 0
            queenPos[row] = -1

backtrack(0) // 求解八皇后问题

代码实现：

public class EightQueens {

    private static int[][] chessboard = new int[8][8]; // 棋盘
    private static int[] queenPos = new int[8]; // 每一行皇后的位置
    private static boolean solutionFound = false; // 是否已经找到一组解

    // 判断两个皇后是否冲突
    private static boolean isConflict(int row1, int col1, int row2, int col2) {
        if (row1 == row2 || col1 == col2 || Math.abs(row1 - row2) == Math.abs(col1 - col2)) {
            return true;
        }
        return false;
    }

    // 输出一组解
    private static void printSolution() {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                if (queenPos[i] == j) {
                    System.out.print("Q ");
                } else {
                    System.out.print(". ");
                }
            }
            System.out.println();
        }
        System.out.println();
    }

    // 递归求解八皇后问题
    private static void backtrack(int row) {
        if (solutionFound) {
            return;
        }
        if (row == 8) {
            printSolution();
            solutionFound = true;
            return;
        }
        for (int col = 0; col < 8; col++) {
            boolean conflict = false;
            for (int i = 0; i < row; i++) {
                if (isConflict(i, queenPos[i], row, col)) {
                    conflict = true;
                    break;
                }
            }
            if (!conflict) {
                queenPos[row] = col;
                chessboard[row][col] = 1;
                backtrack(row + 1);
                chessboard[row][col] = 0;
                queenPos[row] = -1;
            }
        }
    }

    public static void main(String[] args) {
        backtrack(0); // 求解八皇后问题
    }
}

代码中的注释已经说明了每一步的实现方法，如果有不理解的地方可以参考注释或者留言提问。