八皇后算法—java

上次發了個pyhton語言的八皇后算法，這次試試java語言的

直接上代碼，裏面有注釋以便理解閲讀

首先是主函數代碼：

package eighthqueen;

import java.util.*;
import eighthqueen.queenjudgmen;
public class eigqueen {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int data [][] = new int [8][8];//定义一个全0的二维数组，存放皇后位置
		boolean opinion [][] = new boolean [8][8];//定义一个全false的二维数组，判断可存放皇后位置
		//定义的opinion默认值全为false，需先将false改为true以便理解使用
		for(int i =0;i<opinion.length;i++) {
			for(int j=0;j<opinion[0].length;j++) {
				opinion[i][j] = true;
			}
		}
		//定义一个int型数据计算可行次数
		int num = 0;
		//对第一个皇后先判断可存放的位置，用opinion数组判断，true为可存放位置，保存在firstlist中
		char firstlist []= queenjudgmen.findlist(opinion);
		//进行第一个皇后的循环存放
		for(int firstindex = 0;firstindex <firstlist.length/2;firstindex++) {
			//firstlist。length/2   这个是因为每次都取firstlist中的俩个数据比如：长度为4，则循环小于4/2次就可以取完
			
			int firstone = firstlist[firstindex*2]-48;//获取行， （-48）是因为获取的数据是ascll中 1 对应 49的值以此类推
			int firsttwo = firstlist[firstindex*2+1]-48;// 获取列
				
			//发现对于一般的变量复制，new改变，old也会改变
			//由此设置个函数将old变量一一赋值给new，这样new改变，old不会改变
			int firstdata[][] = queenjudgmen.copydata(data);
			boolean firstopinion[][] = queenjudgmen.copyopinion(opinion);
			//令所选皇后位置由0 变为 1
			firstdata[firstone][firsttwo] = 1;
			//令所选皇后位置的行，列，左斜线 \ ，右斜线 /  由true变为false
			firstopinion= queenjudgmen.algjudegment(firstopinion,firstone,firsttwo);
			//改变复制的old数据中皇后所选过的位置true变为false，以免造成后续重复循环相同的答案
			//若不加此句则每个答案会多出7*6*5*4*3*2*1=5040个
			opinion[firstone][firsttwo] = false;
			
			//开始第二个皇后位置存放及判断，同第一个皇后道理一样
			char secondlist [] = queenjudgmen.findlist(firstopinion);
			
			if(secondlist.length == 0) {
				continue;
			}
			else {
				
				for(int secondindex=0;secondindex < secondlist.length/2;secondindex++) {
					
					int secondone = secondlist[secondindex*2]-48;
					int secondtwo = secondlist[secondindex*2+1]-48;
					
					int seconddata[][] = queenjudgmen.copydata(firstdata);
					boolean secondopinion[][] = queenjudgmen.copyopinion(firstopinion);
					
					seconddata[secondone][secondtwo] = 1;
					secondopinion = queenjudgmen.algjudegment(secondopinion, secondone, secondtwo);
					
					firstopinion[secondone][secondtwo] = false;
					//第三个皇后
					char thirdlist [] =queenjudgmen.findlist(secondopinion);
					
					if(thirdlist.length == 0) {
						continue;
					}
					else {
						
						for(int thirdindex=0;thirdindex < thirdlist.length/2;thirdindex++) {
							
							int thirdone = thirdlist[thirdindex*2]-48;
							int thirdtwo = thirdlist[thirdindex*2+1]-48;
							
							int thirddata[][] = queenjudgmen.copydata(seconddata);
							boolean thirdopinion[][] = queenjudgmen.copyopinion(secondopinion);
							
							thirddata[thirdone][thirdtwo] = 1;
							thirdopinion = queenjudgmen.algjudegment(thirdopinion, thirdone, thirdtwo);
							
							secondopinion[thirdone][thirdtwo] = false;
							//第四个皇后
							char fourlist [] =queenjudgmen.findlist(thirdopinion);
							
							if(fourlist.length == 0) {
								continue;
							}
							else {
								
								for(int fourindex=0;fourindex < fourlist.length/2;fourindex++) {
									
									int fourone = fourlist[fourindex*2]-48;
									int fourtwo = fourlist[fourindex*2+1]-48;
									
									int fourdata[][] = queenjudgmen.copydata(thirddata);
									boolean fouropinion[][] = queenjudgmen.copyopinion(thirdopinion);
									
									fourdata[fourone][fourtwo] = 1;
									fouropinion = queenjudgmen.algjudegment(fouropinion, fourone, fourtwo);
									
									thirdopinion[fourone][fourtwo] = false;
									//第五个皇后
									char fifthlist [] = queenjudgmen.findlist(fouropinion);
									
									if(fifthlist.length == 0) {
										continue;
									}
									else {
										
										for(int fifthindex=0;fifthindex < fifthlist.length/2;fifthindex++) {
											
											int fifthone = fifthlist[fifthindex*2]-48;
											int fifthtwo = fifthlist[fifthindex*2+1]-48;
											
											int fifthdata [][] = queenjudgmen.copydata(fourdata);
											boolean fifthopinion [][] = queenjudgmen.copyopinion(fouropinion);
											
											fifthdata[fifthone][fifthtwo] = 1;
											fifthopinion = queenjudgmen.algjudegment(fifthopinion, fifthone, fifthtwo);
											
											fouropinion[fifthone][fifthtwo] = false;
											//第六个皇后
											char sixthlist [] = queenjudgmen.findlist(fifthopinion);
											
											if(sixthlist.length == 0) {
												continue;
											}
											else {
												
												for(int sixthindex=0;sixthindex < sixthlist.length/2;sixthindex++) {
													
													int sixthone = sixthlist[sixthindex*2]-48;
													int sixthtwo = sixthlist[sixthindex*2+1]-48;
													
													int sixthdata[][] = queenjudgmen.copydata(fifthdata);
													boolean sixthopinion[][] = queenjudgmen.copyopinion(fifthopinion);
													
													sixthdata[sixthone][sixthtwo] = 1;
													sixthopinion = queenjudgmen.algjudegment(sixthopinion, sixthone, sixthtwo);
													
													fifthopinion[sixthone][sixthtwo] = false;
													//第七个皇后
													char seventhlist [] = queenjudgmen.findlist(sixthopinion);
													
													if(seventhlist.length == 0) {
														continue;
													}
													else {
														
														for(int seventhindex=0;seventhindex < seventhlist.length/2;seventhindex++) {
															
															int seventhone = seventhlist[seventhindex*2]-48;
															int seventhtwo = seventhlist[seventhindex*2+1]-48;
															
															int seventhdata[][] = queenjudgmen.copydata(sixthdata);
															boolean seventhopinion[][] = queenjudgmen.copyopinion(sixthopinion);
															
															seventhdata[seventhone][seventhtwo] = 1;
															seventhopinion = queenjudgmen.algjudegment(seventhopinion, seventhone, seventhtwo);
															
															sixthopinion[seventhone][seventhtwo] = false;
															//第八个皇后
															char eighthlist[] = queenjudgmen.findlist(seventhopinion);
															
															if(eighthlist.length == 0) {
																continue;
															}
															else {
																
																for(int eighthindex=0;eighthindex < eighthlist.length/2;eighthindex++) {
																	
																	int eighthone = eighthlist[eighthindex*2]-48;
																	int eighthtwo = eighthlist[eighthindex*2+1]-48;
																	
																	int eighthdata[][] = queenjudgmen.copydata(seventhdata);
																	boolean eighthopinion[][] = queenjudgmen.copyopinion(seventhopinion);
																	
																	eighthdata[eighthone][eighthtwo] = 1;
																	eighthopinion = queenjudgmen.algjudegment(eighthopinion, eighthone, eighthtwo);
																	
																	seventhopinion[eighthone][eighthtwo] = false;
																	num++;
																	
																}
															}
														}
													}
												}
											}
										} 
									}
								}
							}
						}
					}
				}
			}
		}
	System.out.println(num);
	}

}

接著是 算法函數代碼

package eighthqueen;

public class queenjudgmen {
	//int 型的二维数组打印
	static void intarrayprint(int data[][]) {
		for(int i =0;i<data.length;i++) {
			for(int j=0;j<data[0].length;j++) {
				System.out.printf("%2d",data[i][j]);
			}
			System.out.println();
		}
	}

	//boolean 型的二维数组打印
	static void booleanarrayprint(boolean opinion[][]){
		for(int i =0;i<opinion.length;i++) {
			for(int j=0;j<opinion[0].length;j++) {
				System.out.printf("%6s",opinion[i][j]);
			}
			System.out.println();
		}
	}
	//查找opinion数据中的true值
	static char[] findlist(boolean opinion[][]) {
		StringBuffer interim = new StringBuffer();
		for(int i = 0;i < opinion.length;i++) {
			for(int j = 0;j < opinion[0].length;j++) {
				if(opinion[i][j] == true) {
					interim.append(i);
					interim.append(j);
				}
			}
		}
		String resultlist = interim.toString();
		
		char resultchar [] = resultlist.toCharArray();
		
		return resultchar;
		
	}
	//实现对每次皇后的data的复制
	static int[][]copydata(int data[][]) {
		
		int changedata[][] = new int [data.length][data[0].length];
		
		for(int i =0;i<data.length;i++) {
			for(int j=0;j<data[0].length;j++) {
				changedata[i][j] = data[i][j];
			}
		}
		return changedata;
	}
	//实现对每次皇后的opinion的复制
	static boolean[][] copyopinion(boolean opinion[][]) {
		boolean changeopinion[][] = new boolean [opinion.length][opinion[0].length];
		
		for(int i =0;i<opinion.length;i++) {
			for(int j=0;j<opinion[0].length;j++) {
				changeopinion[i][j] = opinion[i][j];
			}
		}
		return changeopinion ;
	}

	//对皇后行，列，左斜线 \ ，右斜线 / 的条件限定
	static boolean[][] algjudegment(boolean opinion[][],int row,int train){
		int newrow = row;
		int newtrain = train;
		opinion[newrow][newtrain] = false;
		//行
		while(newtrain!=0) {
			newtrain-=1;
			opinion[newrow][newtrain] = false;
		}
		newtrain=train;
		while(newtrain!=7) {
			newtrain+=1;
			opinion[newrow][newtrain] = false;
		}
		newtrain=train;
		//列
		while(newrow!=0) {
			newrow-=1;
			opinion[newrow][newtrain] = false;
		}
		newrow = row;
		while(newrow!=7) {
			newrow+=1;
			opinion[newrow][newtrain] =false;
		}
		//左斜线 \
		newrow = row;
		//任意行或列減一为零
		while(newrow!=0 && newtrain!=0) {
			newrow-=1;
			newtrain-=1;
			opinion[newrow][newtrain] = false;
		}
		newrow = row;
		newtrain = train;
		//任意行或列加一为七
		while(newrow!=7 && newtrain!=7) {
			newrow+=1;
			newtrain+=1;
			opinion[newrow][newtrain] = false;
		}
		//右斜线 /
		newrow = row;
		newtrain = train;
		//行加列减，最大为七，最小为零
		while(newrow!=7 && newtrain!=0) {
			newrow+=1;
			newtrain-=1;
			opinion[newrow][newtrain] = false;
		}
		newrow = row;
		newtrain = train;
		//行减列加，最小为零，最大为七
		while(newrow!=0 && newtrain!=7) {
			newrow-=1;
			newtrain+=1;
			opinion[newrow][newtrain] = false;
		}
		
		return opinion;
	}
}

结果92种