搭积木

最新推荐文章于 2021-04-11 10:39:59 发布

原创最新推荐文章于 2021-04-11 10:39:59 发布 · 341 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#暴力破解法 #dfs

算法题专栏收录该内容

75 篇文章

订阅专栏

本文探讨了一种使用数字积木搭建金字塔形结构的算法问题，提供了两种不同的解决方案：暴力破解法和深度优先搜索（DFS）。通过这两种方法计算出了所有可能的搭建方案数量。

小明最近喜欢搭数字积木，

一共有10块积木，每个积木上有一个数字，0~9。

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

下面是两种合格的搭法：

0
1 2
3 4 5
6 7 8 9

0
3 1
7 5 2
9 8 6 4

请你计算这样的搭法一共有多少种？

第一种方法：暴力破解法

public class Main{

	public static void main(String[] args) {
		
		int count=0;
		
		int a,b,c,d,e,f,g,h,i,j;
		
		for(a=0;a<10;a++)  
		for(b=0;b<10;b++)  
	    for(c=0;c<10;c++)  
	    for(d=0;d<10;d++)  
	    for(e=0;e<10;e++) 
	    for(f=0;f<10;f++)  
	    for(g=0;g<10;g++)  
	    for(h=0;h<10;h++)  
	    for(i=0;i<10;i++)
	    for(j=0;j<10;j++)
	    	
	            if(a!=b && a!=c && a!=d && a!=e && a!=f && a!=g && a!=h && a!=i && a!=j &&  
	               b!=c && b!=d && b!=e && b!=f && b!=g && b!=h && b!=i && b!=j && 
	               c!=d && c!=e && c!=f && c!=g && c!=h && c!=i && c!=j && 
	               d!=e && d!=f && d!=g && d!=h && d!=i && d!=j &&
	               e!=f && e!=g && e!=h && e!=i && e!=j && 
	               f!=g && f!=h && f!=i && f!=j &&
	               g!=h && g!=i && g!=j &&
	               h!=i && h!=j &&
	               i!=j){ 
	            	
	            	if(a<b && a<c){
	            		if(b<d && b<e && c<e && c<f){
	            			if(d<g && d<h && e<h && e<i && f<i && f<j ){
	            				
	            				count++;
	            			}
	            		}
	            	}
	             }
			
			System.out.println(count);     //768
			
	    }
  }

第二种方法：dfs

public class Main{
	
	public static int count=0;
	
	public static void swap(int[] A,int a,int b){
		
		int temp=A[a];
		
		A[a]=A[b];
		
		A[b]=temp;
		
	}
	
	public static void dfs(int[] A,int step){
		
		if(step==A.length){
			
			if(check(A)){
				
				count++;
			}
				
		}else{
			
			for(int i=step;i<A.length;i++){
				
				swap(A, i, step);
				
				dfs(A, step+1);
				
				swap(A, i, step);
				
			}
		}		
	}
	
	public static boolean check(int[] A){
		
		if(A[0] < A[1] && A[0] < A[2]){
			
			if(A[1] < A[3] && A[1] < A[4] && A[2] < A[4] && A[2] < A[5]){
				
				if(A[3] < A[6] && A[3] < A[7] && A[4] < A[7] && A[4] < A[8] && A[5] < A[8] && A[5] < A[9]){
					
					return true;
					
				}
			}
		}
		
		return false;
		
	}
	
	public static void main(String[] args){
		
		int [] A={0,1,2,3,4,5,6,7,8,9}; 
		
		dfs(A, 0);
		
		System.out.println(count);   
	}
}