八皇后

两个思路，可以用排列剪枝，更普遍的是用图的DFS。

/**
 * 八皇后问题。
 * 实际就是n个相邻元素的全排列加剪枝。
 * 
 *
 */
public class EightQueen {

	public static int count;

	public static void place(int[] a, int begin, int end) {
		assert (true);
		if (begin == end) {
			if (isValid(a, begin)) {
				Tools.printArray(a);
				count++;
			}
			return;
		}
		for (int i = begin; i <= end; i++) {
			Tools.swap(a, begin, i);
			if (isValid(a, begin)) {
				place(a, begin + 1, end);
			}
			Tools.swap(a, begin, i);
		}
	}

	private static boolean isValid(int[] a, int p) {
		assert (true);
		//第一个不用测试
		if (p == 0)
			return true;
		for (int i = 0; i < p; i++) {
			if (((a[i] - a[p]) == (i - p)) || ((a[i] - a[p]) == (p - i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 0, 1, 2, 3, 4, 5, 6, 7 };
		EightQueen.place(a, 0, a.length - 1);
		System.out.println(count);

	}

}

/**
 * 图的DFS
 * 
 * 对每个未搜索的顶点会调用一次递归算法，所以有O(V)。又会对每个点的邻近边扫描一次，时间为O(E)。
 * 于是DFS的总运行时间也为O(V + E)
 * 对于二叉树，特殊的一种图，从下往上看，一个点对应一条边，所以DFS是O(n).
 * 
 *
 */
public class EightQueen {

	public static int count = 0;
	public final static  int N = 8;
	
	public static  void dfs(int[] a, int k){
		if(k == N){
			count++;
			return;
		}
		for(int i=0; i<N; i++){
			a[k] = i;
			if(canPlace(a, k)){
				dfs(a, k+1);
			}
		}
	}
	
	private static boolean canPlace(int[] a, int k){
		for(int j=0; j<k; j++){
			if(a[k]==a[j] || a[k]-a[j]==k-j || a[k]-a[j]==j-k){
				return false;
			}
		}
		return true;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = new int[8];
		EightQueen.dfs(a, 0);
		System.out.println(count);
	}

}