8皇后问题

时间:2011-02-03 06:36:57

标签: java c++ algorithm n-queens

我如何实现8/4皇后问题?我应该使用DFS / BFS,我认为DF会更好。 任何人都可以提供一些伪代码/指南吗?

5 个答案:

答案 0 :(得分:2)

使用堆栈和回溯,最简单的方法是通过递归。

请参阅其他SO帖子:

Dumb 8 Queens problem in C++

答案 1 :(得分:1)

DFS确实是解决方案,应该作为回溯实现。

有关解决方案的说明,请参阅here

如果您不理解链接中的任何描述,请询问。

一切顺利。

答案 2 :(得分:0)

我的解决方案有2个预定义的逻辑,行中只有一个皇后,列上只有一个皇后。 有一个长度为8的一维数组。所有数组值都设置为0-7之一,但所有值都使用了一次(值为0-7的排列) arr [0] = 5值表示第一行第6列的女王 arr [1] = 3值表示第二列第4列的女王, 只需控制数组检查中的交叉违规值,就不需要检查行或行违规。所有你需要的排列和交叉违规函数,(C ++ STL具有排列函数,只需要交叉违规函数)

答案 3 :(得分:0)

如果女王位于(i,j)和(k,l)坐标,那么他们可以互相攻击

  1. i = k(同一行)
  2. j = l(同一栏)
  3. | I-K | = | J-升| (对角线),| |表示绝对值

    bool place(k,i)
    {
    //returns true if the queen can be placed at k-th row and i-th column
    //x[] is a global array with first (k-1) values set already.
    //x[p]=q means a queen is at location (p,q)
    
    for(j=1 to k-1)
    {
    if(x[j]==i)||(ABS(x[j]-i)==ABS(j-k))  //checking if another queen in same column or     diagonally
    return false;
    }
    return true;
    }
    

    使用回溯打印所有可能的展示位置:

    无效NQueens(k,n)  {

    for(i=1 to n)
    {
    if(place(k,i)) //checking if queen can be placed at (k,i)
    {
    x[k]=i;
    if(k==n) then write (x[1:n]);  
    else Nqueens(k+1,n);
     }
     }
    }
    
  4. *参考saurabh学校

答案 4 :(得分:0)

这是我使用回溯的实现。 更改 N 的值以获取不同的解决方案。

它将打印给定数量的皇后可用的所有解决方案。

package com.org.ds.problems;

public class NQueueProblem {
private static int totalSolution = 0;
    public static void main(String[] args) {
        int n = 5;
        int arr[][] = new int[n][n];
        backTrack(arr, 0);
        System.out.println("\nTotal Number of Solutions are:- " + totalSolution);
    }

    private static void printQueuens(int[][] arr) {
        totalSolution++;
        System.out.println("\n========Start Printing Solution "+totalSolution+"=========");
        for(int i=0; i<arr.length;i++) {
            for(int j=0; j<arr.length;j++) {
                if(arr[i][j] == 1)
                    System.out.print(" Q"+(i+1) + " |");
                else
                    System.out.print("    |");
            }
            System.out.println();
        }
    }

    private static boolean backTrack(int[][] arr, int row) {
        if (row < 0 || row >= arr.length)
            return true;

        for (int col = 0; col < arr.length; col++) {
            if (isAttacked(arr, row, col)) {
                arr[row][col] = 1;
                if (backTrack(arr, row + 1)) {
                    if(row == (arr.length-1)) {
                        printQueuens(arr);
                        arr[row][col] = 0;
                    }
                    else {
                        return true;    
                    }
                } else {
                    arr[row][col] = 0;
                }
            }
        }
        return false;
    }

    private static boolean isAttacked(int[][] arr, int row, int col) {
        if (row == 0)
            return true;
        // check for same row
        for (int i = 0; i < arr.length; i++) {
            if (arr[row][i] == 1)
                return false;
        }
        // check for same col
        for (int i = 0; i <= row; i++) {
            if (arr[i][col] == 1)
                return false;
        }
        // check for diagonal
        // a.) Left dia
        int i = row - 1;
        int j = col - 1;
        while (i >= 0 && j >= 0) {
            if (arr[i][j] == 1)
                return false;
            i--;
            j--;
        }
        // b.) right dia
        i = row - 1;
        j = col + 1;
        while (i >= 0 && j < arr.length) {
            if (arr[i][j] == 1)
                return false;
            i--;
            j++;
        }
        return true;
    }
}