笨办法解决 八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

 

本人以数学坐标为依据进行计算：

假设棋盘的左下角空格坐标为  x:1,y:1 ,右上角 空格坐标  x:8,y:8

1.经过观察可以发现，八个皇后，任意两个都不可能在同一行或者同一列。

2.我们可以以x轴做为参照，进行推算。

如果第一行 x轴的坐标 x1，那么第二行的坐标 x2 一定不能等于 {x1}，第三行坐标 x3 一定不能等于{ x1，x2}，第四行坐标x4 不能等于 {x1，x2，x3}, 以此类推。。。 

第八行 x 坐标 x8一定不能等于 {x1，x2,x3,x4,x5,x6,x7}

 3.对第二步骤进行过滤条件。

4.对于斜角不能在一条线上。那么  任意一个 点 a(x,y) 与任意 非a点的  b(x,y) 有个斜率值。 

若 ： (ax-bx)/(ay-by)==1 或者 (ax-bx)/(ay-by)==-1，则说明他们在一条斜线上。

 

package comp;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Point {

    int row=0;
    int col=0;
    public Point  add(int row,int col){
     this.row=row;
     this.col=col;
     return this;
    }

    @Override
    public String toString() { 
        return  "(y:"+row+",x:"+col+")";
    }
    public static void main(String[] args) {
        
    TreeMap<Integer,List<Point>> p=new TreeMap<Integer,List<Point>>();

        for(int row=1;row<=8;row++){
        List<Point> ps=new ArrayList<Point>(); 
            for(int col=1;col<=8;col++){ 
                ps.add(new Point().add(row, col)); 
            }  
            p.put(row, ps); 
        }
        
        
        int times=1;
        
        List<Integer>ss=new ArrayList<Integer>();
        for(Point p1:p.get(1)){
        
            ss.add(p1.col);
            
            
            for(Point p2:p.get(2)){
                
                if(ss.contains(p2.col)){
                    continue;
                }else{
                    ss.add(p2.col);
                }
                 
                
                
                for(Point p3:p.get(3)){
                    
                    if(ss.contains(p3.col)){
                        continue;
                    }else{
                        ss.add(p3.col);
                    }
                    
                    
                    for(Point p4:p.get(4)){ 

                        if(ss.contains(p4.col)){
                            continue;
                        }else{
                            ss.add(p4.col);
                        }
                        
                        
                        
                        for(Point p5:p.get(5)){
                            
                            
                            if(ss.contains(p5.col)){
                                continue;
                            }else{
                                ss.add(p5.col);
                            }
                            
                            
                            
                            for(Point p6:p.get(6)){
                                
                                if(ss.contains(p6.col)){
                                    continue;
                                }else{
                                    ss.add(p6.col);
                                }
                                
                                
                                for(Point p7:p.get(7)){
                                    
                                    
                                    if(ss.contains(p7.col)){
                                        continue;
                                    }else{
                                        ss.add(p7.col);
                                    }
                                    
                                    
                                    for(Point p8:p.get(8)){
                                        
                                        if(ss.contains(p8.col)){
                                            continue;
                                        }else{
                                            ss.add(p8.col);
                                        }
                                        
                                        ss.remove(ss.size()-1); 
                                         
                                        List<Point>pps=new ArrayList<Point>();
                                        pps.add(p1);
                                        pps.add(p2);
                                        pps.add(p3);
                                        pps.add(p4);
                                        pps.add(p5);
                                        pps.add(p6);
                                        pps.add(p7);
                                        pps.add(p8); 
                                        
                                        boolean rigth=true;
                                        for(Point px:pps){
                                            
                                            if(!rigth){
                                                break;
                                            }
                                            
                                             
                                            double ppr=0;
                                            for(Point py:pps){
                                             ppr=px.col-py.col; 
                                                 
                                                if(px.col==py.col){
                                                    continue;
                                                }else if((ppr)/(px.row-py.row)==1||(ppr)/(px.row-py.row)==-1){  
                                                    rigth=false;
                                                    break;
                                                }
                                                
                                                
                                                
                                            }
                                            
                                        }
                                        
                                        
                                        if(rigth){
                                            
                                            System.out.println(p1+"-"+p2+"-"+p3+"-"+p4+"-"+p5+"-"+p6+"-"+p7+"-"+p8+"-------->>"+times++); 
                                        } 
                                        
                                        
                                    }
                                    
                                    ss.remove(ss.size()-1);
                                    
                                    
                                }
                                
                                
                                ss.remove(ss.size()-1);
                                
                            }
                            
                            
                            ss.remove(ss.size()-1);
                        }
                        
                        
                        
                        
                        ss.remove(ss.size()-1);
                    }
                    
                    
                    
                    ss.remove(ss.size()-1);
                    
                }
                
                /**/
                
                
                ss.remove(ss.size()-1);
            }
            
            ss.clear(); 
            
        } 
        
        
        
        
    } 
    
      
    
    
}