N-Queens

要求：

国际象棋中，一个n*n的棋盘，如果有n个皇后，怎样的摆法可以让任意皇后不能攻击其他皇后，皇后可以横着走，竖着走，斜着走。

输入：n

输出：

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

第一种方法，用一个map记录皇后可以攻击到的位置，如果下一个皇后的位置在这个map中，则说明这个位置不行：

import java.util.*;

public class NQueens {
    public static void main(String[] args) {
        NQueens nQueens=new NQueens();
        System.out.println(nQueens.solveNQueens(4));
    }
    
    List<List<String>> result=new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        if(n==1){
            return Arrays.asList(Arrays.asList("Q"));
        }
        
        for (int i = 0; i < n; i++) {
            Set<Integer> resultSet=new HashSet<>();
            resultSet.add(i);
            Map<Integer,Set<Integer>> map=new HashMap();
            map.put(0,getHava(0,i,n));

            M(n-1,n,map,resultSet);
        }

        return result;
    }
    
    private void M(int count,int n,Map<Integer,Set<Integer>> map,Set<Integer> resultSet){

        if(count==1){
            for (int j = 0; j < n; j++) {
                boolean tag=true;
                for(Set<Integer> tempSet:map.values()){
                    if(tempSet.contains(count*10 + j)){
                        tag=false;
                        break;
                    }
                }
                if(tag){
                    resultSet.add(count*10+j);

                    if(resultSet.size()==n){
                        List<String> list=new ArrayList<>(n);
                        Map tMap=new HashMap();

                        for(int parms:resultSet){
                            int x=parms/10;
                            int y=parms%10;

                            StringBuilder sb=new StringBuilder();
                            for (int m = 0; m < n; m++) {
                                if(m==y){
                                    sb.append("Q");
                                }else {
                                    sb.append(".");
                                }
                            }
                            tMap.put(x,sb.toString());
                        }

                        for (int m = 0; m < n; m++) {
                            list.add(tMap.get(m).toString());
                        }
                        result.add(list);
                        resultSet.remove(count*10+j);
                    }
                }
            }
        }else {
            for (int j = 0; j < n; j++) {

                boolean tag=true;
                for(Set<Integer> tempSet:map.values()){
                    if(tempSet.contains(count*10 + j)){
                        tag=false;
                        break;
                    }
                }

                if(tag){
                    Set<Integer> tMap=getHava(count, j, n);
                    map.put(count,tMap);
                    resultSet.add(count*10+j);
                    M(count-1,n,map,resultSet);

                    resultSet.remove(count*10+j);
                    map.remove(count);
                }
            }
        }
    }

    private Set<Integer> getHava(int x,int y,int n){

        Set<Integer> haveData=new HashSet<>();

        //第一种情况（x,n）
        int i=0;
        while (i<n){
            haveData.add(x*10+i);
            i++;
        }
        //第二种情况（y,n）
        i=0;
        while (i < n) {
            haveData.add(i * 10 + y);
            i++;
        }
        //第三种情况（x-i,y-i）
        int x1=x-1;
        int y1=y-1;
        while (x1 > -1 && y1 > -1) {
            haveData.add(x1*10+y1);
            x1--;
            y1--;
        }
        //第四种情况（x+i,y+i）
        x1=x+1;
        y1=y+1;
        while (x1 < n && y1 < n) {
            haveData.add(x1*10+y1);
            x1++;
            y1++;
        }
        //第五中情况（x-i,y+i）
        x1=x-1;
        y1=y+1;
        while (x1 > -1 && y1 < n) {
            haveData.add(x1*10+y1);
            x1--;
            y1++;
        }
        //第六种情况（x+i,y-i）
        x1=x+1;
        y1=y-1;
        while (x1 < n && y1 > -1) {
            haveData.add(x1*10+y1);
            x1++;
            y1--;
        }
        return haveData;
    }
}

结果挺low：

晚上睡觉，想到第二种方式，

定义一个数组，以数组的下标记录为棋盘的行号，数组的值作为棋盘的列号，循环每行，在每行找到一个合适的位置，也不用维护一个map，

如下，循环第一行：

循环第二行：

循环第三行，如果第三行没有合适的位置，则返回第二行继续循环：

代码如下：

import java.util.*;
public class NQueensV2 {
    public static void main(String[] args) {
        NQueensV2 nQueens=new NQueensV2();
        System.out.println(nQueens.solveNQueens(4));
    }
    
    List<List<String>> result=new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        if(n==1){
            return Arrays.asList(Arrays.asList("Q"));
        }
        int[] resultArray=new int[n];

        for (int i = 0; i < n; i++) {
            resultArray[0]=i;
            getQueensIndex(1,n,resultArray);
        }
        return result;
    }

    private void getQueensIndex(int index,int total,int[] array){
        if(index==(total-1)){
            for (int i = 0; i < total; i++) {
                if(isLegal(index,array,i)){
                    array[index]=i;

                    List<String> list=new ArrayList<>();
                    for (int j = 0; j < total; j++) {
                        StringBuilder sb=new StringBuilder();
                        for (int k = 0; k < total; k++) {
                            if(array[j]==k){
                                sb.append("Q");
                            }else {
                                sb.append(".");
                            }
                        }
                        list.add(sb.toString());
                    }

                    result.add(list);
                }
            }
        }else {
            for (int i = 0; i < total; i++) {
                if(isLegal(index,array,i)){
                    array[index]=i;
                    getQueensIndex(index+1,total,array);
                }
            }
        }
    }

    //验证合法
    private boolean isLegal(int rowIndex,int[] array,int colIndex){
        int j=1;
        for (int i = rowIndex-1; i >=0; i--) {
            int preColIndex=array[i];
            if(preColIndex==colIndex||(colIndex-j)==preColIndex||(colIndex+j)==preColIndex){
                return false;
            }
            j++;
        }
        return true;
    }
}

结果还是有很大进步的：