蓝桥杯省赛搭积木解题方法

题目：

小明最近喜欢搭数字积木， 一共有10块积木，每个积木上有一个数字，0~9。 搭积木规则： 每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。 最后搭成4层的金字塔形，必须用完所有的积木。

下面是两种合格的搭法：         0      1    2    3   4   5 6   7   8   9

         0       3   1    7   5   2 9   8   6   4 请你计算这样的搭法一共有多少种？注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。768;

当然最简单的方式是暴利破解，这里使用数据结构的全排列和深搜，向大家和我一起掌握这两种简单的数据结构，提升一下自己。

深度优先搜索

package LX;
public class 搭积木_DFS{
	
	//记录访问过的位置
	static int[] visited = new int[10];
	//记录访问的路径
	static int[] path = new int[10];
	static int count=0;
	
	public static void main(String[]args){
		dfs(1);
		System.out.println(count);
	}
	public static void dfs(int k){
		
		//优化提前剪枝
		if(k>1&&!check(path,k-1)){//判断上一个位置是否满足条件。
			return;
		}
		
		if(k==path.length&&check(path,k-1)){
			count++;
			return;
		}
		
		for(int i=1;i<visited.length;i++){
			
			if(visited[i]==0){
				
				path[k] = i;
				visited[i] = 1;//标记已经使用的位置
				
				dfs(k+1);	//递归
				
				visited[i] = 0;//回溯
			}
		}
	}
	
	
	
	public static boolean check(int[]path,int k){
		
		boolean flag = false;
		
		//提前剪枝
		switch(k){
			case 1:flag=(path[0]<path[1]);break;
			case 2:flag=(path[0]<path[2]);break;
			case 3:flag=(path[1]<path[3]);break;
			case 4:flag=(path[1]<path[4]&&path[2]<path[4]);break;
			case 5:flag=(path[2]<path[5]);break;
			case 6:flag=(path[3]<path[6]);break;
			case 7:flag=(path[3]<path[7]&&path[4]<path[7]);break;
			case 8:flag=(path[4]<path[8]&&path[5]<path[8]);break;
			case 9:flag=(path[5]<path[9]);break;
		}
		
//		if(m[0]<m[1]&&m[0]<m[2]&&
//			m[1]<m[3]&&m[1]<m[4]&&
//			m[2]<m[4]&&m[2]<m[5]&&
//			m[3]<m[6]&&m[3]<m[7]&&
//			m[4]<m[7]&&m[4]<m[8]&&
//			m[5]<m[8]&&m[5]<m[9]){
//			flag = true;
//		}
		return flag;
		
	}
}

全排列

package LX;
public class 搭积木_全排列{
	static int count=0;
	public static void main(String[]args){
		int[] m = {0,1,2,3,4,5,6,7,8,9};
		f(0,m);
		System.out.println(count);
	}
	public static void f(int k,int[]m){
		
		//优化提前剪枝
		if(k>1&&!check(m,k-1)){//判断上一个位置是否满足条件。
			return;
		}
		
		if(k==m.length-1&&check(m,k)){
			count++;
			return;
		}
		for(int i=k;i<m.length;i++){
			
			{int t=m[i];m[i]=m[k];m[k]=t;}//交換位置
			
			f(k+1,m);//递归
			
			{int t=m[i];m[i]=m[k];m[k]=t;}//回溯
		}
	}
	
	public static boolean check(int[]m,int k){
		
		boolean flag = false;
		
//		//提前剪枝优化减少运算时间。
//		switch(k){
//			case 1:flag=(m[0]<m[1]);break;
//			case 2:flag=(m[0]<m[2]);break;
//			case 3:flag=(m[1]<m[3]);break;
//			case 4:flag=(m[1]<m[4]&&m[2]<m[4]);break;
//			case 5:flag=(m[2]<m[5]);break;
//			case 6:flag=(m[3]<m[6]);break;
//			case 7:flag=(m[3]<m[7]&&m[4]<m[7]);break;
//			case 8:flag=(m[4]<m[8]&&m[5]<m[8]);break;
//			case 9:flag=(m[5]<m[9]);break;
//		}
		
		if(m[0]<m[1]&&m[0]<m[2]&&
			m[1]<m[3]&&m[1]<m[4]&&
			m[2]<m[4]&&m[2]<m[5]&&
			m[3]<m[6]&&m[3]<m[7]&&
			m[4]<m[7]&&m[4]<m[8]&&
			m[5]<m[8]&&m[5]<m[9]){
			flag = true;
		}
		return flag;
		
	}
}