薛聚坡

java-八皇后问题

八皇后问题是一个很经典的算法问题。不知道八皇后是啥的同学。。。可以略过了。

八皇后和四皇后是一样的，为了简单起见，下面先考虑四皇后：

首先，在4*4的方格内放4个皇后，他们相互不攻击，应该有一个基本的概念：如果有这么一种放皇后的方法，那么4个皇后肯定是每行一个，并且每列一个。这是最基本的。

其次，斜行怎么表示是皇后问题的一个比较重要的点。考虑一个四乘四的16个方格，第i行第j列，和第i+1行第j+1列，和第i+1行，第j-1列都是斜行。可以发现，对于从左上到右下的斜行，i-j是一个定值。对于右上到左下的斜行，i+j是定值，所以很自然的想到用一个容量为2*n的数组存储每一个方格的相应斜行是否可用。

想到怎么表现一个方格是否可用，就开始解决皇后问题。既然如果皇后问题有解，那么肯定是每行有且只有一个解，那么自然就想到循环所有行，然后遍历这个行的所有列，查看行，列相应位置被占用，是不是可以组成一个解。

还是上代码：

package javaCode;

import java.util.Arrays;

/**
 * @ClassName: EightQueen
 * @Description: 这里用一句话描述这个类的作用
 * @author xuejupo [email protected]
 * @date 2015-11-10 上午11:11:08
 */

public class EightQueen {
	private static int sum = 0;
	
	//n皇后题目解法
	private static int num = 0;
	// n皇后问题
	private static final int n = 4;

	// 同栏是否有皇后，true表示有
	private boolean[] haveQueenForColumn;

	// 从右上到左下的斜栏中是否有皇后
	private boolean[] fromRightTop;

	// 从左上到右下的斜栏中是否有皇后
	private boolean[] fromLeftTop;

	// 解集
	private int[] queen;

	// 解答编号
	// private int num;

	public EightQueen() {
		haveQueenForColumn = new boolean[n + 1];
		fromRightTop = new boolean[(2 * n) + 1];
		fromLeftTop = new boolean[(2 * n) + 1];
		queen = new int[n + 1];
	}

	/**  
	* @Title: backtrack  
	* @Description: 这里用一句话描述这个方法的作用 
	* @param i 
	* @return void    返回类型   
	*/
	public void backtrack(int i) {
		
//		System.out.println(i);
		if (i > n) {
//			System.out.println(Arrays.toString(queen));
			System.out.println("----------------最终结果:");
			print();
                        //有一个解就退出，便于分析问题
			System.exit(1);
		} else {
			for (int j = 1; j <= n; j++) {
				if ((!haveQueenForColumn[j]) && (!fromRightTop[i + j])
						&& (!fromLeftTop[i - j + n])) {
					// 如果没有皇后
					queen[i] = j;
					System.out.println("----------------第"+ sum++ +"步");
					System.out.println("占住第"+i+"行,第"+j+"列的位置，并且把相应的斜行设为占用，结果为：");
					print();
					// 设定为占用
					haveQueenForColumn[j] = fromRightTop[i + j] = fromLeftTop[i - j + n] = true;
					//第i行已经有数据了，然后开始遍历第i+1行
					backtrack(i + 1); 
					haveQueenForColumn[j] = fromRightTop[i + j] = fromLeftTop[i - j + n] = false;
					queen[i] = 0;
					System.out.println("----------------第"+ sum++ +"步");
					System.out.println("发现第"+i+"行,第"+j+"列的位置走不通，把相应位置去掉,结果：");
					print();
				}
			}
		}
	}

	protected void print() {
//		System.out.println("解法"+ ++num +":-------------");
		for (int y = 1; y <= n; y++) {
			for (int x = 1; x <= n; x++) {
				if (queen[y] == x) {
					System.out.print(" Q");
				} else {
					System.out.print(" *");
				}
			}

			System.out.println();
		}
	}

	public static void main(String[] args) {
		EightQueen queen = new EightQueen();
		queen.backtrack(1);
	}
}

执行结果：

----------------第0步
占住第1行,第1列的位置，并且把相应的斜行设为占用，结果为：
 Q * * *
 * * * *
 * * * *
 * * * *
----------------第1步
占住第2行,第3列的位置，并且把相应的斜行设为占用，结果为：
 Q * * *
 * * Q *
 * * * *
 * * * *
----------------第2步
发现第2行,第3列的位置走不通，把相应位置去掉,结果：
 Q * * *
 * * * *
 * * * *
 * * * *
----------------第3步
占住第2行,第4列的位置，并且把相应的斜行设为占用，结果为：
 Q * * *
 * * * Q
 * * * *
 * * * *
----------------第4步
占住第3行,第2列的位置，并且把相应的斜行设为占用，结果为：
 Q * * *
 * * * Q
 * Q * *
 * * * *
----------------第5步
发现第3行,第2列的位置走不通，把相应位置去掉,结果：
 Q * * *
 * * * Q
 * * * *
 * * * *
----------------第6步
发现第2行,第4列的位置走不通，把相应位置去掉,结果：
 Q * * *
 * * * *
 * * * *
 * * * *
----------------第7步
发现第1行,第1列的位置走不通，把相应位置去掉,结果：
 * * * *
 * * * *
 * * * *
 * * * *
----------------第8步
占住第1行,第2列的位置，并且把相应的斜行设为占用，结果为：
 * Q * *
 * * * *
 * * * *
 * * * *
----------------第9步
占住第2行,第4列的位置，并且把相应的斜行设为占用，结果为：
 * Q * *
 * * * Q
 * * * *
 * * * *
----------------第10步
占住第3行,第1列的位置，并且把相应的斜行设为占用，结果为：
 * Q * *
 * * * Q
 Q * * *
 * * * *
----------------第11步
占住第4行,第3列的位置，并且把相应的斜行设为占用，结果为：
 * Q * *
 * * * Q
 Q * * *
 * * Q *
----------------最终结果:
 * Q * *
 * * * Q
 Q * * *
 * * Q *

一步一步分析代码结果：

首先，第0步，肯定是占据第1行第1列，然后在第二行的时候用

(!haveQueenForColumn[j]) && (!fromRightTop[i + j])
						&& (!fromLeftTop[i - j + n])

判断条件，判断第二行的第j列是否可用，如果可用，那么占住该位置，结果判断出第二行第一列和第二列都不可用（因为和第一行第一列的数据冲突）。

第二步，判断第三行，发现第二行第三列占住之后，第三行放什么都走不通了，返回第二行处理，把第二行第三列位置去掉。

第三步，占住第二行第四列，然后balabalabala。。。跟前几步判断条件一样，最终得到4行都可以放位置的一个位置组合。

大家可能不明白，以后复习时候也可能会疑惑的地方：

// 如果没有皇后
					queen[i] = j;

queen[i] = j; 表示第i行第j列被占用了。

haveQueenForColumn[j] = fromRightTop[i + j] = fromLeftTop[i - j + n] = true;
					//第i行已经有数据了，然后开始遍历第i+1行
					backtrack(i + 1); 
					haveQueenForColumn[j] = fromRightTop[i + j] = fromLeftTop[i - j + n] = false;

backtrack(i + 1);为什么放到这里？这就是回溯法。如果这个表示，当第i行，第j列处理完以后，他会清掉第i行第j列的占用（haveQueenForColumn[j] = fromRightTop[i + j] = fromLeftTop[i - j + n] = false;），然后继续第i+1行，不管第i行处理结果是什么，所以如果代码里面不加这个System.exit(1); 程序会打印出所有的结果。

八皇后其实和四皇后是一样的，只是n不一样而已。令n=8，并且去掉单步打印语句，执行代码后结果：

解法1:-------------
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
解法2:-------------
 Q * * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * Q * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * Q * * * * * *
 * * * * Q * * *
解法3:-------------
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
 * * Q * * * * *
解法4:-------------
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 * * * * * Q * *
 * * Q * * * * *
解法5:-------------
 * Q * * * * * *
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
解法6:-------------
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
解法7:-------------
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * Q *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
解法8:-------------
 * Q * * * * * *
 * * * * * Q * *
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * * * * * * * Q
 * * Q * * * * *
 * * * * Q * * *
解法9:-------------
 * Q * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * Q * * * * *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * Q *
 * * * * Q * * *
解法10:-------------
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * * * Q * * *
 Q * * * * * * *
 * * * Q * * * *
解法11:-------------
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * Q * * * *
 * * * * * Q * *
 * * Q * * * * *
解法12:-------------
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * Q *
 * * * Q * * * *
解法13:-------------
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 * * * * * Q * *
解法14:-------------
 * * Q * * * * *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * * * * * Q * *
解法15:-------------
 * * Q * * * * *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
解法16:-------------
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
解法17:-------------
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
解法18:-------------
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
解法19:-------------
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * * Q
 * * * * Q * * *
解法20:-------------
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * Q * * * *
解法21:-------------
 * * Q * * * * *
 * * * * * Q * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
解法22:-------------
 * * Q * * * * *
 * * * * * Q * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
解法23:-------------
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * Q *
 * * * * Q * * *
 * Q * * * * * *
解法24:-------------
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
解法25:-------------
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
解法26:-------------
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * Q * *
解法27:-------------
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * Q * * *
解法28:-------------
 * * Q * * * * *
 * * * * * * * Q
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * Q * * *
解法29:-------------
 * * * Q * * * *
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
解法30:-------------
 * * * Q * * * *
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
解法31:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * * * * * Q * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * Q *
解法32:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * Q * * *
解法33:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * * * Q * * *
 Q * * * * * * *
解法34:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
解法35:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
解法36:-------------
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * Q *
解法37:-------------
 * * * Q * * * *
 * * * * * Q * *
 Q * * * * * * *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
 * * Q * * * * *
 * * * * * * Q *
解法38:-------------
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
解法39:-------------
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * Q * * * * * *
解法40:-------------
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
解法41:-------------
 * * * Q * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
 Q * * * * * * *
 * * * * * Q * *
解法42:-------------
 * * * Q * * * *
 * * * * * * Q *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * Q * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * * Q
解法43:-------------
 * * * Q * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
解法44:-------------
 * * * Q * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *
解法45:-------------
 * * * Q * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
解法46:-------------
 * * * Q * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
解法47:-------------
 * * * * Q * * *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
解法48:-------------
 * * * * Q * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
解法49:-------------
 * * * * Q * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
解法50:-------------
 * * * * Q * * *
 * Q * * * * * *
 * * * Q * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
解法51:-------------
 * * * * Q * * *
 * Q * * * * * *
 * * * Q * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * * * Q
 * * * * * Q * *
 Q * * * * * * *
解法52:-------------
 * * * * Q * * *
 * Q * * * * * *
 * * * * * Q * *
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * * * * * * * Q
 * * Q * * * * *
解法53:-------------
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * Q *
 * * Q * * * * *
 * * * * * Q * *
解法54:-------------
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 * * * * * * Q *
解法55:-------------
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
解法56:-------------
 * * * * Q * * *
 * * Q * * * * *
 * * * * * * * Q
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * * * Q * *
 * Q * * * * * *
解法57:-------------
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
 * Q * * * * * *
解法58:-------------
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * Q * * * * *
解法59:-------------
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
解法60:-------------
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * * Q
解法61:-------------
 * * * * Q * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * Q * * * *
解法62:-------------
 * * * * Q * * *
 * * * * * * Q *
 * * * Q * * * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * Q * * * * * *
解法63:-------------
 * * * * Q * * *
 * * * * * * * Q
 * * * Q * * * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
解法64:-------------
 * * * * Q * * *
 * * * * * * * Q
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
解法65:-------------
 * * * * * Q * *
 Q * * * * * * *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
 * * Q * * * * *
 * * * * * * Q *
 * * * Q * * * *
解法66:-------------
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * * * Q * * * *
解法67:-------------
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * Q * * * * *
解法68:-------------
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
解法69:-------------
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *
解法70:-------------
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * Q * * * * * *
 * * * Q * * * *
 * * * * * * Q *
解法71:-------------
 * * * * * Q * *
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
解法72:-------------
 * * * * * Q * *
 * * Q * * * * *
 * * * * Q * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * Q *
解法73:-------------
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
 * * * * * * * Q
 Q * * * * * * *
 * * * * Q * * *
解法74:-------------
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * Q * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 Q * * * * * * *
 * * * Q * * * *
解法75:-------------
 * * * * * Q * *
 * * Q * * * * *
 * * * * * * Q *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
解法76:-------------
 * * * * * Q * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * * * Q *
 * * Q * * * * *
解法77:-------------
 * * * * * Q * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
解法78:-------------
 * * * * * Q * *
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
 * Q * * * * * *
 * * * * * * * Q
解法79:-------------
 * * * * * Q * *
 * * * Q * * * *
 * * * * * * Q *
 Q * * * * * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
 * * Q * * * * *
解法80:-------------
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * Q * * * * *
解法81:-------------
 * * * * * * Q *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * * * Q
 * * * * * Q * *
 * * * Q * * * *
 * Q * * * * * *
 * * * * Q * * *
解法82:-------------
 * * * * * * Q *
 * Q * * * * * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * * Q
 * * * * Q * * *
 * * Q * * * * *
 * * * * * Q * *
解法83:-------------
 * * * * * * Q *
 * Q * * * * * *
 * * * * * Q * *
 * * Q * * * * *
 Q * * * * * * *
 * * * Q * * * *
 * * * * * * * Q
 * * * * Q * * *
解法84:-------------
 * * * * * * Q *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * * * * Q * * *
 * Q * * * * * *
 * * * Q * * * *
解法85:-------------
 * * * * * * Q *
 * * Q * * * * *
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
 Q * * * * * * *
 * * * * * Q * *
 * * * Q * * * *
解法86:-------------
 * * * * * * Q *
 * * * Q * * * *
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * * Q
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
解法87:-------------
 * * * * * * Q *
 * * * Q * * * *
 * Q * * * * * *
 * * * * * * * Q
 * * * * * Q * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * Q * * *
解法88:-------------
 * * * * * * Q *
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * Q * *
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
解法89:-------------
 * * * * * * * Q
 * Q * * * * * *
 * * * Q * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * * Q * * *
 * * Q * * * * *
 * * * * * Q * *
解法90:-------------
 * * * * * * * Q
 * Q * * * * * *
 * * * * Q * * *
 * * Q * * * * *
 Q * * * * * * *
 * * * * * * Q *
 * * * Q * * * *
 * * * * * Q * *
解法91:-------------
 * * * * * * * Q
 * * Q * * * * *
 Q * * * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * Q * * *
 * * * * * * Q *
 * * * Q * * * *
解法92:-------------
 * * * * * * * Q
 * * * Q * * * *
 Q * * * * * * *
 * * Q * * * * *
 * * * * * Q * *
 * Q * * * * * *
 * * * * * * Q *
 * * * * Q * * *

Java-网络胡净 java 网络开发语言
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。1.网络协议Java支持多种网络协议，最常用的包括：TCP（传输控制协议）：面向连接的协议，确保数据的可靠传输。UDP（用户数据报协议）：无连接的协议，适用于对速度要求高但对可靠性要求低的应用。网络通信模型通常指的是OSI（开放系统互联）模型，它将网络通信分为七个层次。每一层
Java-后端程序员个人知识总结金肴羽 java 开发语言
文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
探索C#编程：高效解决N皇后问题的回溯算法实现 AitTech 算法算法 c#开发语言
在C#中，回溯算法是一种通过探索所有可能的候选解来找出所有解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化来撤销上一步或上几步的计算，以获得新的候选解。这个过程一直进行，直到找到所有解或确定无解。回溯算法常用于解决组合问题、排列问题、子集问题、棋盘问题（如八皇后问题）、图的着色问题、旅行商问题等。示例：C#中的回溯算法实现N皇后问题N皇后问题是一个
Java-实现双向环形链表 Bro_cat 数据结构与算法链表数据结构 java 双向环形链表
双向链表是一种常用的数据结构，其特点是每个节点不仅包含数据，还持有指向前一个节点和后一个节点的指针。与普通双向链表不同的是，它的哨兵节点的prev指向最后一个元素，而最后一个元素的next指向哨兵。具体双向普通链表可以参考我的上篇文章，这里是传送门。什么是双向环形链表？双向环形链表不仅支持双向遍历，还形成一个闭合环，即最后一个节点的next指针指向链表的头部，第一个节点的prev指针指向链表的尾部
java编程题——八皇后问题 sdg_advance java 算法排序算法数据结构
背景及问题介绍：八皇后问题（英文：Eightqueens），是由国际象棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果经过±9
Maven项目结构说明 HachiLin SpringBoot maven springboot 微服务
1.maven概念是一个基于Java平台的自动化构建工具（make->ant->maven->gradle，它主要有五大功能：（1）清理：删除编译的结果，为重新编译做准备（2）编译：java->class（3）测试：针对与项目中的关键点进行测试，方便开发人员与测试人员交互（4）报告：将测试结果进行显示（5）打包：将项目中包含的多个文件压缩成一个文件，用于安装或部署（java项目打成jar包，web
设计模式 —— 单例模式 idealzouhu 设计模式设计模式单例模式
文章目录一、单例模式1.1单例模式定义1.2单例模式的优点1.3单例模式的缺点1.4单例模式的使用场景二、普通案例2.1饿汉式单例模式(EagerInitializationSingleton)2.2懒汉式单例模式(LazyInitializationSingleton)参考资料本文源代码地址为java-demos/singeleton-patternatmain·idealzouhu/java-
Java-线程的生命周期&7大状态 Bro_cat Java java 开发语言
在Java中，线程的生命周期可以分为多个状态，这些状态描述了线程从创建到终止的整个过程。Java线程的生命周期主要包括以下七大状态：1.新建状态（New）当一个线程对象被创建但尚未调用start()方法时，线程处于新建状态。此时，线程还没有开始执行。2.可运行状态（Ready）当调用start()方法后，线程进入可运行状态。在这个状态下，线程可能正在运行，也可能在等待操作系统分配CPU时间片。3.
八皇后问题代码实现（java，递归）手搓二十四种设计模式 java 开发语言
简介：著名的八皇后问题是由棋手马克斯·贝瑟尔在1848年提出来的，要求在8×8的棋盘上摆放8个皇后，使”皇后“们不能互相攻击，当任意两个皇后都不处于同一行、同一列或同一条斜线上时就不会相互攻击，即为目标解。说明：本文之创建一个数组，索引代表行，对应的值代表列publicclassBaHuangHouWenTi{//定义一个max表示共有多少个皇后intmax=8;//定义数组arry，保存存放的结
Java-环境理解（JDK、JRE、JVM）云淡风轻聊技术 java 笔记
day-1我们再学习java之前首先需要了解JDK、JRE、JVM都是什么？以及三者之间的关系又是怎么样的？以及为什么Java被称之为WriteOneRunAnwhere(一次运行到处编译)。然后我带着以上3个问题进行以下的慢慢学习路！JDK、JRE、JVM分别是什么JDK：（JavaDevelopmentKit）也就是Java开发工具包，包含了Java开发所需要的各种工具和类库。也包含了JRE。
JAVA-案例练习-基础进阶复习 W.KN JAVA学习笔记 java 笔记
关于JAVA学习后的一些复习题目，提供一些解法和总结一下自己的学习问题。目录1.集合的灵活应用需求：代码实现2.数据分割转换和统计需求：代码实现3.休息日计算需求：代码实现4.数组模拟需求代码实现5.数组排列需求代码实现6.链表问题需求*7.问题总结1.集合的灵活应用需求：目前有100名囚犯，每个囚犯的编号是1~200之间的随机数。现在要求依次随机生成1~100名囚犯的编号，要求这些囚犯的编号是不
韩顺平Java-第十一章：枚举和注解 weixin_47199727 java
一枚举1自定义类实现枚举-应用实例（1）定义规范①不需要提供setXxx方法每一位枚举对象值通常为只读；②对枚举对象/属性使用final+static共同修饰，实现底层优化；③枚举对象名通常使用全部大写，常量的命名规范；④枚举对象根据需要，也可以有多个属性。（2）小结进行自定义类实现枚举，有如下特点：①对构造器私有化；②本类内部创建一组对象；③对外暴露对象（通过为对象添加publicfinalst
Java-通用的配置文件读取工具类 ZHOU_VIP MAC java 开发语言
为了提供一个全面且易于使用的工具类来读取各种格式的配置文件，我们可以创建一个通用的配置文件读取工具类，支持.properties、.xml、.json和.yaml格式的配置文件。下面是一个示例实现：工具类设计思路统一接口：创建一个统一的接口，无论配置文件是什么格式，都可以通过同样的方法获取配置项。异常处理：确保在读取配置文件时能够妥善处理可能出现的异常。缓存机制：为了提高性能，可以考虑将配置文件的
Java-文件读取工具类FileReaderUtil ZHOU_VIP MAC java 开发语言
为了创建一个最全的文件读取工具类，我们将整合多种文件读取功能，并提供缓存机制和文件变化监听功能。下面是一个综合性的示例实现，该工具类支持以下功能：读取文本文件：支持.txt、.properties、.xml、.json和.yaml格式的文件。读取二进制文件：支持读取任意二进制文件。缓存机制：对于文本文件，提供缓存机制以提高性能。文件变化监听：监听文件的变化，自动更新缓存。importcom.fas
Java-泛型 ZHOU_VIP MAC java
Java泛型是一个强大的特性，它允许你在编写代码时使用类型参数来提高代码的复用性和类型安全性。以下是从入门到精通的Java泛型指南，包括基本概念、使用方法以及高级主题。1.泛型的基本概念1.1什么是泛型？泛型是一种在编译时检查类型安全，并且所有的强制转换都是自动和隐式的编程构造。使用泛型可以避免在运行时进行类型转换错误，并且可以使代码更加灵活和易于维护。1.2为什么使用泛型？类型安全：避免运行时出
【java-面试题】start和run的区别一朵忽明忽暗的云 java-面试题 java 多线程编程 start和run的区别面试题
【java-面试题】start和run的区别在run方法内部，只是单纯的描述了该线程要执行的内容。run方法是线程的入口。在start方法内部，会调用到系统api，从而在系统内核中创建出线程，创建线程后，再自动调用run方法。在代码中，我们通过重写run方法创建一个线程对象，但创建一个线程对象并不意味着线程开始执行了。而调用start方法后，才真正在操作系统底层创建出一个线程，同时start方法内
Effective Java-对于所有对象都通用的方法勇往直前888
覆盖equals时请遵守通用约定自反性。对象必须等于自身。对称性。任何两个对象对于“它们是否相等”的问题都必须保持一致。传递性。如果一个对象等于第二个对象，并且第二个对象等于第三个对象，则第一个对象一定等于第三个对象一致性。如果两个对象相等，它们就必须始终保持相等，除非它们中有一个对象（或者两个都）被修改了。非空性。所有的对象都必须不等于null覆盖equals时总要覆盖hashCode对一个对象
035-安全开发-JavaEE应用&原生反序列化&重写方法&链条分析&触发类&类加载 wusuowei2986 安全 java-ee python
035-安全开发-JavaEE应用&原生反序列化&重写方法&链条分析&触发类&类加载#知识点：1、JavaEE-反序列化-解释&使用&安全2、JavaEE-安全-利用链&直接重写方法3、JavaEE-安全-利用链&外部重写方法演示案例：➢Java-原生使用-序列化&反序列化➢Java-安全问题-重写方法&触发方法➢Java-安全问题-可控其他类重写方法#Java序列化&反序列化-概念1、序列化与反
036-安全开发-JavaEE应用&第三方组件&Log4j日志&FastJson序列化&JNDI注入 wusuowei2986 安全 java-ee log4j
036-安全开发-JavaEE应用&第三方组件&Log4j日志&FastJson序列化&JNDI注入#知识点：1、JavaEE-组件安全-Log4j2、JavaEE-组件安全-Fastjson3、JavaEE-基本了解-JNDI-API演示案例：➢Java-三方组件-Log4J&JNDI➢Java-三方组件-FastJson&反射#Java-项目管理工具-配置Jar仓库：https://mvnre
Java-长字符串加密奇遇少年 java 加密
引言：在数据安全领域，加密技术是保护信息不被未授权访问的重要手段。特别是在处理长字符串时，如何保证加密后的数据既安全又高效，是一个值得探讨的话题。本文将介绍几种常见的加密算法，并展示如何在Java中实现这些算法，以实现长字符串的有效加密。一、加密概念简介加密是一种将明文转换为密文的过程，目的是为了在不安全的通道上安全地传输数据。在加密过程中，只有拥有正确密钥的用户才能将密文解密并恢复原始数据。二、
Java-贪吃蛇游戏 YCY^v^ Java项目笔记贪吃蛇游戏 java
视频效果：贪吃蛇视频效果，简单的小项目，Java项目-贪吃蛇注意images的图片是在proxiangmu下的，不可放在模块！！不然图片加载不出来1.准备工作JDK版本：JDK8.0开发工具：IDEA2.设计游戏图纸实现700*900宽度值为700像素，每个格子为25像素，共计有28个格子宽度值为900像素，每个格子为25像素，共计有36个格子3.画出700*900像素窗口编写具体代码如下：pac
java-场景题 HBryce24 java
1、项目中的分布式锁redis分布式锁：获取锁：SETNX为避免死锁设置过期时间()key过期，业务却未处理完在锁将要过期的时候，如果服务还没有处理完业务，那么将这个锁再续一段时间。比如设置key在10s后过期，那么再开启一个守护线程，在第8s的时候检测服务是否处理完，如果没有，则将这个key再续10s后过期。Redisson已实现，这个自动续时的我们称其为”看门狗”。释放锁：delSETNX底层
JAVA-冒泡排序详解二小闻排序算法算法 java 数据结构
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档冒泡排序前言一、冒泡排序二、具体代码如下1.代码内容2.输出结果三、总结前言八大排序算法直接插入排序希尔排序选择排序堆排序冒泡排序快速排序归并排序计数排序一、冒泡排序冒泡排序无疑是最为出名的排序算法之一，总共有八大排序冒泡排序的代码相当简单，俩层循环，外层冒泡轮数，里层依次比较二、具体代码如下1.代码内容代码如下（示例）：/***冒泡
JAVA-数组乱序 zyt.com java python 算法
实现步骤假设有一组数组numbers从数组中最后一个元素开始遍历设置一个随机数作为循环中遍历到的元素之前的所有元素的下标，即可从该元素之前的所有元素中随机取出一个每次将随机取出的元素与遍历到的元素交换，即可完成乱序实例如下：importjava.util.Arrays;publicclassR18{publicstaticvoidmain(String[]args){int[]numbers={1
java-工具类(校验整数、返回指定字符在某字符串中出现的次数) 爱PSUI设计的星星
作者：mooncharmzx链接：https://blog.bccn.net/mooncharmzx/66337话不多说，直接上代码importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.regex.Pattern;publicclassSt
Java-字符串 H_7835
1、Java没有内置的字符串类型，而是预定义类String，用双引号括起来的字符串都是String的实例e.gStringstr="abc"2、字符串不可变不能直接将字符串的字符改变为其他值e.gstr1="abc"str1="abd"在上例中直接将str1中的'c'改变为'd'是没有办法的，如果想要修改，可以提取想要保留的字串，再进行替换e.gstr1=str1.substring(0,2)+'
JAVA-数组查找元素 zyt.com 算法数据结构
无序数组查找元素循环遍历查找通过对无序数组进行遍历，将数组中的每个元素与指定元素比较，从而确定该数组中是否存在指定元素。字符串数组publicstaticvoidmain(String[]args){String[]arr={"Megatron","s司马铁锤","Laden","angelbaby","b比尔盖茨","1林平之","BIGBAM"};Stringtarget="s司马铁锤";in
java-保姆级IO流详解吾乃零陵上将军邢道荣是也
一、File类1.1概述java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。抽像：1.2构造方法publicFile(Stringpathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。publicFile(Stringparent,Stringchild)：从父路径名字符串和子路径名字符串创建新的File实例。publi
回溯算法一乐乐
一、回溯1、定义：通过选择不同的岔路口来通往目的地（找到想要的结果）每一步都选择一条路出发，能进则进，不能进则退回上一步（回溯），换一条路再试【回溯很适合使用递归】举例：二叉树的前序遍历、图的深度优先搜索、八皇后、走迷宫都是典型的回溯应用2、八皇后问题任意两个皇后都不能处于同一行、同一列、同一斜线上，请问有多少种摆法？■解法：回溯+剪枝图片.png☆巧妙的地方：1、类比二叉树，二叉树是以节点为单位
Java-数组宋夏寒 Java java python 开发语言
文章目录1.概述2.一维数组的声明3.数组的初始化1).动态初始化2).静态初始化4.数组元素的引用5.一维数组的练习1).数组的输出和String[]args的用法2).实现加减乘除3).读入并排序4).冒泡排序5).数三退一6).二分法查找6.二维数组二维数组的初始化1).静态初始化2).动态初始化7.数组的拷贝1.概述数组可以看成是多个相同类型数据组合，对这些数据的统一管理。数组变量属引用类
jquery实现的jsonp掉java后台知了ing java jsonp jquery
什么是JSONP？先说说JSONP是怎么产生的：其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 2、
Struts2学习笔记 caoyong struts2
SSH : Spring + Struts2 + Hibernate 三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 分层原则:单向依赖，接口耦合 1、Struts2 = Struts + Webwork 2、搭建struts2开发环境 a>、到www.apac
SpringMVC学习之后台往前台传值方法满城风雨近重阳 springMVC
springMVC控制器往前台传值的方法有以下几种： 1.ModelAndView 通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参： ModelAndView mv=new ModelAndView(); mv.setViewName="success
WebService存在的必要性？一炮送你回车库 webservice
做Java的经常在选择Webservice框架上徘徊很久，Axis Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。当在不同的平台间传输数据时，就需要一个都能解析的数据格式。但是为什么要使用xml呢？不能使json或者其他通用数据
js年份下拉框 3213213333332132 java web ee
<div id="divValue">test...</div>测试 //年份 <select id="year"></select> <script type="text/javascript"> window.onload =
简单链式调用的实现技术归来朝歌方法调用链式反应编程思想
在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用这样的调用你可能在Ajax中，在页面中添加标签： $("<p>").append($("<span>").text(list[i].name)).appendTo("#result"); 也可能在HQ
JAVA调用.net 发布的webservice 接口 darkranger webservice
/** * @Title: callInvoke * @Description: TODO(调用接口公共方法) * @param @param url 地址 * @param @param method 方法 * @param @param pama 参数 * @param @return * @param @throws BusinessException
Javascript模糊查找 | 第一章循环不能不重视。 aijuans Way
最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： function search(){ var arr=new Array("my
狼和羊，该怎么抉择 atongyeye 工作
狼和羊，该怎么抉择在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
读取android系统的联系人拨号百合不是茶 android sqlite数据库内容提供者系统服务的使用
联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢关键代码: 1, 使用javabean操作存储读取到的数据 package com.example.bean; /** * * @author Admini
ORACLE自定义异常 bijian1013 数据库自定义异常
实例： CREATE OR REPLACE PROCEDURE test_Exception ( ParameterA IN varchar2, ParameterB IN varchar2, ErrorCode OUT varchar2 --返回值,错误编码 ) AS /*以下是一些变量的定义*/ V1 NUMBER; V2 nvarc
查看端号使用情况征客丶 windows
一、查看端口在windows命令行窗口下执行： >netstat -aon|findstr "8080" 显示结果： TCP 127.0.0.1:80 0.0.0.0:0 &
【Spark二十】运行Spark Streaming的NetworkWordCount实例 bit1129 wordcount
Spark Streaming简介 NetworkWordCount代码 /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with
Struts2 与 SpringMVC的比较 BlueSkator struts2 spring mvc
1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
Hibernate在更新时，是可以不用session的update方法的(转帖） BreakingBad Hibernate update
地址：http://blog.csdn.net/plpblue/article/details/9304459 public void synDevNameWithItil() {Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
读《研磨设计模式》-代码笔记-观察者模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; import java.util.Observable; import java.util.Observer; /** * “观
重置MySQL密码 chenhbc mysql 重置密码忘记密码
如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 1、关闭MySQL服务 2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL mysqld --skip-grant-tables 3、新开一个CMD窗口，进入MySQL mysql -uroot
再谈系统论，控制论和信息论 comsci 设计模式生物能源企业应用领域模型
再谈系统论，控制论和信息论偶然看
oracle moving window size与 AWR retention period关系 daizj oracle
转自： http://tomszrp.itpub.net/post/11835/494147 晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. SQL> select * from v$version; BANNER -------------------
Python版B树 dieslrae python
话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 首先是数据实体对象,很简单,只存放key,value class Entity(object): '''数据实体''' def __init__(self,key,value)
C语言冒泡排序 dcj3sjt126com 算法
代码示例： # include <stdio.h> //冒泡排序 void sort(int * a, int len) { int i, j, t; for (i=0; i<len-1; i++) { for (j=0; j<len-1-i; j++) { if (a[j] > a[j+1]) // >表示升序
自定义导航栏样式 dcj3sjt126com 自定义
-(void)setupAppAppearance { [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]]; [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
11.性能优化-优化-JVM参数总结 frank1234 jvm参数性能优化
1.堆 -Xms --初始堆大小 -Xmx --最大堆大小 -Xmn --新生代大小 -Xss --线程栈大小 -XX:PermSize --永久代初始大小 -XX:MaxPermSize --永久代最大值 -XX:SurvivorRatio --新生代和suvivor比例,默认为8 -XX:TargetSurvivorRatio --survivor可使用
nginx日志分割 for linux HarborChung nginx linux 脚本
nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限复制代码代码如下: chmo
Spring4新特性——泛型限定式依赖注入 jinnianshilongnian spring spring4 泛型式依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
centOS安装GCC和G++ liuxihope centos gcc
Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。按照这个思路，我想安装过程如下：安装gcc：yum install gcc 安装g++： yum install g++ 实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
第13章 Ajax进阶（上） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
How to determine BusinessObjects service pack and fix pack blueoxygen BO
http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/ The table below is helpful. Reference BOE XI 3.x 12.0.0. y BOE XI 3.0 12.0. x. y BO
Oracle里的自增字段设置 tomcat_oracle oracle
　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列 create table t ( id 　　　　 number generated by default as identity (start with 1 increment b
Spring Security（01）——初体验 yang_winnie spring Security
Spring Security（01）——初体验博客分类： spring Security Spring Security入门安全认证首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置

java-八皇后问题

你可能感兴趣的:(java-八皇后问题)