笨办法解决 八皇后问题

Posted 2020-06-25 吃饭了吗

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于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，则说明他们在一条斜线上。

 

  1 package comp;
  2 
  3 import java.util.ArrayList;
  4 import java.util.HashMap;
  5 import java.util.HashSet;
  6 import java.util.List;
  7 import java.util.Map;
  8 import java.util.Set;
  9 import java.util.TreeMap;
 10 
 11 public class Point {
 12 
 13     int row=0;
 14     int col=0;
 15     public Point  add(int row,int col){
 16      this.row=row;
 17      this.col=col;
 18      return this;
 19     }
 20 
 21     @Override
 22     public String toString() { 
 23         return  "(y:"+row+",x:"+col+")";
 24     }
 25     public static void main(String[] args) {
 26         
 27     TreeMap<Integer,List<Point>> p=new TreeMap<Integer,List<Point>>();
 28 
 29         for(int row=1;row<=8;row++){
 30         List<Point> ps=new ArrayList<Point>(); 
 31             for(int col=1;col<=8;col++){ 
 32                 ps.add(new Point().add(row, col)); 
 33             }  
 34             p.put(row, ps); 
 35         }
 36         
 37         
 38         int times=1;
 39         
 40         List<Integer>ss=new ArrayList<Integer>();
 41         for(Point p1:p.get(1)){
 42         
 43             ss.add(p1.col);
 44             
 45             
 46             for(Point p2:p.get(2)){
 47                 
 48                 if(ss.contains(p2.col)){
 49                     continue;
 50                 }else{
 51                     ss.add(p2.col);
 52                 }
 53                  
 54                 
 55                 
 56                 for(Point p3:p.get(3)){
 57                     
 58                     if(ss.contains(p3.col)){
 59                         continue;
 60                     }else{
 61                         ss.add(p3.col);
 62                     }
 63                     
 64                     
 65                     for(Point p4:p.get(4)){ 
 66 
 67                         if(ss.contains(p4.col)){
 68                             continue;
 69                         }else{
 70                             ss.add(p4.col);
 71                         }
 72                         
 73                         
 74                         
 75                         for(Point p5:p.get(5)){
 76                             
 77                             
 78                             if(ss.contains(p5.col)){
 79                                 continue;
 80                             }else{
 81                                 ss.add(p5.col);
 82                             }
 83                             
 84                             
 85                             
 86                             for(Point p6:p.get(6)){
 87                                 
 88                                 if(ss.contains(p6.col)){
 89                                     continue;
 90                                 }else{
 91                                     ss.add(p6.col);
 92                                 }
 93                                 
 94                                 
 95                                 for(Point p7:p.get(7)){
 96                                     
 97                                     
 98                                     if(ss.contains(p7.col)){
 99                                         continue;
100                                     }else{
101                                         ss.add(p7.col);
102                                     }
103                                     
104                                     
105                                     for(Point p8:p.get(8)){
106                                         
107                                         if(ss.contains(p8.col)){
108                                             continue;
109                                         }else{
110                                             ss.add(p8.col);
111                                         }
112                                         
113                                         ss.remove(ss.size()-1); 
114                                          
115                                         List<Point>pps=new ArrayList<Point>();
116                                         pps.add(p1);
117                                         pps.add(p2);
118                                         pps.add(p3);
119                                         pps.add(p4);
120                                         pps.add(p5);
121                                         pps.add(p6);
122                                         pps.add(p7);
123                                         pps.add(p8); 
124                                         
125                                         boolean rigth=true;
126                                         for(Point px:pps){
127                                             
128                                             if(!rigth){
129                                                 break;
130                                             }
131                                             
132                                              
133                                             double ppr=0;
134                                             for(Point py:pps){
135                                              ppr=px.col-py.col; 
136                                                  
137                                                 if(px.col==py.col){
138                                                     continue;
139                                                 }else if((ppr)/(px.row-py.row)==1||(ppr)/(px.row-py.row)==-1){  
140                                                     rigth=false;
141                                                     break;
142                                                 }
143                                                 
144                                                 
145                                                 
146                                             }
147                                             
148                                         }
149                                         
150                                         
151                                         if(rigth){
152                                             
153                                             System.out.println(p1+"-"+p2+"-"+p3+"-"+p4+"-"+p5+"-"+p6+"-"+p7+"-"+p8+"-------->>"+times++); 
154                                         } 
155                                         
156                                         
157                                     }
158                                     
159                                     ss.remove(ss.size()-1);
160                                     
161                                     
162                                 }
163                                 
164                                 
165                                 ss.remove(ss.size()-1);
166                                 
167                             }
168                             
169                             
170                             ss.remove(ss.size()-1);
171                         }
172                         
173                         
174                         
175                         
176                         ss.remove(ss.size()-1);
177                     }
178                     
179                     
180                     
181                     ss.remove(ss.size()-1);
182                     
183                 }
184                 
185                 /**/
186                 
187                 
188                 ss.remove(ss.size()-1);
189             }
190             
191             ss.clear(); 
192             
193         } 
194         
195         
196         
197         
198     } 
199     
200       
201     
202     
203 }