LS_FIGHTING

2015年javaB组蓝桥杯

2.立方变自身

观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1
8^3 = 512 5+1+2=8
17^3 = 4913 4+9+1+3=17
...

请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？

请填写该数字，不要填写任何多余的内容或说明性的文字。6

public class Main {
	public static void main(String[] args){
		int count = 0;
		for(int i = 1;i < 500;i ++){
			int lifang = (int) Math.pow(i, 3);
			if(qushuwei(lifang) == i){
				count++;
			}
		}
		System.out.print(count);
	}

	private static int qushuwei(int lifang) {
		// TODO Auto-generated method stub
		int a = lifang%10;
		int sum = a;
		while(lifang/10 !=0){
			int b = lifang/10%10;
			lifang = lifang/10;
			sum = sum+b;
		}
		return sum;
	}
}

（1）经过分析可以判断出满足这个条件的整数肯定在500以内，当然还可以再缩小一下范围，这不是很重要啦，数据不是很多。

（2）本题目的关键在于取位数，使用while循环

3.三羊献瑞

观察下面的加法算式：

祥瑞生辉
+ 三羊献瑞
-------------------
三羊生瑞气

(如果有对齐问题，可以参看【图1.jpg】)

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。1085

public class Main {
	public static void main(String[] args){
		int a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0;
		for(a = 1;a < 10;a++){
			for(b = 0;b < 10;b++){
				for(c = 0;c < 10;c++){
					for(d = 0;d < 10;d++){
						for(e = 1;e < 10;e++){
							for(f = 0;f < 10;f++){
								for(g = 0;g < 10;g++){
									for(h = 0;h < 10;h++){
										int i = a*1000+b*100+c*10+d;
										int j = e*1000+f*100+g*10+b;
										int k = e*10000+f*1000+c*100+b*10+h;
										if(a!=b && a!=c && a!=d && a!=e && a!=f && a!=g && a!=h 
												&& b!=c && b!=d && b!=e && b!=f && b!=g && b!=h 
												        && c!=d && c!=e && c!=f && c!=g && c!=h
												                && d!=e && d!=f && d!=g && d!=h
												                        && e!=f && e!=g && e!=h
												                                && f!=g && f!=h
												                                        && g!=h&&(i + j == k)){
												System.out.println(j);
												
										}										
									}
								}
							}
						}
					}						
				}
			}
		}
	}

}

直接使用暴力循环，注意题目中的要求，不要漏掉判断条件。

回溯法有通用解题法之称，它可以系统的搜索一个问题的所有解或者任意解。它在问题的解空间树中，按深度优先策略从根节点出发搜索解空间树，算法搜索至解空间树的任意一个结点时，先判断该节点如（子树）是否包含问题的解，如果肯定不包含，则跳过对其子树的搜索，逐层向其根节点回溯。否则，则按照深度优先的策略搜索子树。

当回溯到根，且根节点的所有子树都已被搜索遍才结束。这种以深度优先方式系统搜索问题解的算法称为回溯法，适用于解决组合数较大的问题。

4.六角填数

如图【1.png】所示六角形中，填入1~12的数字。使得每条直线上的数字之和都相同。

图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？

请通过浏览器提交答案，不要填写多余的内容。

public class Main {
	static int []a = new int[15];
	static int []visit = new int[15];
	public static void main(String[] args){
		
		a[0] = 1;
		a[1] = 8;
		a[11] = 3;
		visit[1] = 1;
		visit[8] = 1;
		visit[3] = 1;
		dfs(0);
		
	}

	private static void dfs(int x) {
		// TODO Auto-generated method stub
		
		if(x == 0||x == 1||x == 11){
			dfs(x+1);
			return;
		}
		
		if(x == 12){
			int []b = new int[6];
			b[0] = a[0]+a[2]+a[5]+a[7];
			b[1] = a[0]+a[3]+a[6]+a[10];
			b[2] = a[1]+a[2]+a[3]+a[4];
			b[3] = a[1]+a[5]+a[8]+a[11];
			b[4] = a[4]+a[6]+a[9]+a[11];
			b[5] = a[7]+a[8]+a[9]+a[10];
			
			for(int i = 1;i < 6;i++){
				if(b[i-1] != b[i])
					return;
			}
			System.out.print(a[5]);
			return;
		}
		
		for(int i = 2;i < 13;i++){
			if(visit[i] == 0){
				visit[i] = 1;
				a[x] = i;
				dfs(x+1);
				visit[i] = 0;
			}
		}
	}
}

如果用暴力，未知量的个数比较多，条件太复杂，此路不通。采用深度优先算法，dfs(int x)中间的x表示初始节点。

return;

上面的return语句用于终止方法并返回到方法的调用者，可以改变void方法中的正常流程控制。

5.五星填数

如【图1.png】的五星图案节点填上数字：1~12，除去7和11。
要求每条直线上数字和相等。

如图就是恰当的填法。

请你利用计算机搜索所有可能的填法有多少种。
注意：旋转或镜像后相同的算同一种填法。

请提交表示方案数目的整数，不要填写任何其它内容。

12

public class Main {
	static int []a = new int[15];
	static int []visit = new int[15];
	static int sum ;
	static int []f = {1,2,3,4,5,6,8,9,10,12};
	
	public static void main(String[] args){
		
		dfs(0);
		System.out.println(sum/5/2);
	}
	
	private static void dfs(int x) {
		// TODO Auto-generated method stub
		int []b = new int[5];
		b[0] = a[0]+a[2]+a[5]+a[8];
		b[1] = a[0]+a[3]+a[6]+a[9];
		b[2] = a[1]+a[2]+a[3]+a[4];
		b[3] = a[1]+a[5]+a[7]+a[9];
		b[4] = a[4]+a[6]+a[7]+a[8];
		
		if(x == 10){
			if(b[0] == b[1] && b[0] ==b[2] && b[0]==b[3] && b[0]==b[4]){
				sum++;
			}
			return;
		}
		
		for(int i = 0;i < f.length;i++){
			if(visit[f[i]] == 0){
				visit[f[i]] = 1;
				a[x] = f[i];
				dfs(x+1);
				visit[f[i]] = 0;
				}
			}	
	}

}

采用深度优先算法，最后去除镜像/2，取出旋转/5

6.标题：纸牌三角形

A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。

A
9 6
4 8
3 7 5 2

这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。

注意：需要提交的是一个整数，不要提交任何多余内容。144

public class Main {
	static int []a = new int[12];
	static int []visit = new int[12];
	static int sum = 0 ;
 	public static void main(String[] args){
		dfs(0);
		System.out.println(sum/2/3);
	}
 	
	private static void dfs(int x) {
		// TODO Auto-generated method stub
		int []b = new int[4];
		b[0] = a[0]+a[1]+a[3]+a[5];
		b[1] = a[0]+a[2]+a[4]+a[8];
		b[2] = a[5]+a[6]+a[7]+a[8];
		if(x == 9){
			if(b[0] == b[1]&&b[0]==b[2])
				sum++;
			return;
		}
		for(int i = 1;i < 10;i++){
			if(visit[i] == 0){
				visit[i] = 1;
				a[x] = i;
				dfs(x+1);
				visit[i] = 0;	
			}
		}
	}
}

7.带分数

问题描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714。

还可以表示为：100 = 82 + 3546 / 197。

注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。

类似这样的带分数，100 有 11 种表示法。

输入格式

从标准输入读入一个正整数N (N<1000*1000)

输出格式

程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。

注意：不要求输出每个表示，只统计有多少表示法！

样例输入1

100

样例输出1

11

样例输入2

105

样例输出2

6

建造剪枝条件：

(1)n=n1+n2/n3；

(2)首先n1一定是小于n的:n1

(3)因为n为整数，n1为整数，所以n2/n3也应为整数，这就要求n2/n3一定可以整除，即n2%n3==0；

(4)n2/n3还要满足可除条件，即n2>=n3。

在1至9的全排列（9个数字）中确定n1，n2，n3的取值范围：

(1)n1能从第1位，取到第7位，肯定取不到第8和第9位。

(2)n2>=n3，则n2的取值范围一定在n1选择后，选择剩下的一半或一半以上的数据。

举个例子，1至9的其中一个全排列--156987423，若n1选择156，则n2只能选择剩下的987423中的一半或

一半以上，如987、9874、98742，如果n2小于剩下的一半，则不满足条件。

(3)n3的范围则是n1和n2选择剩下的所有了。

如果n1选择9位中的前i位，那么n2的结尾j选择范围为第i+（9-i+1）/2至第8位数字，n3是从第j位至第9位。

利用深度优先搜索（得到一个9位的全排列）和适当的判断（剪枝，找出符合4个条件的全排列）就可以解决。

import java.util.Scanner;

public class Main {
	static int []a = {1,2,3,4,5,6,7,8,9};
	static int []visit = new int[10];
	static int n,n1,n2,n3;
	static int count = 0;
	
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		n = input.nextInt();
		if(n < 1000000 && n > 0){
			dfs(0);
			System.out.println(count);
		}
	}
	
	private static int sum(int begin, int end) {
		int k = 0;
		for(int i = begin;i <= end ;i++)
			k = k*10 + a[i];
		return k;
	}

	private static void dfs(int x) {
		if(x == 9){
			for(int i = 0;i <= 5;i++){
				n1= sum(0,i);
				if(n1 >=  n)
					break;
				for(int j = i+(10-i)/2;j <= 7;j++){
					n2 = sum(i+1,j);
					n3 = sum(j+1,8);	
					if(n2>=n3 && n2%n3==0 && n==n1+n2/n3){
						count++;
					}
				}
				
			}
			return;
		}
		
		for(int i = 1; i <= 9;i++){
			if(visit[i] == 0){
				visit[i] = 1;
				a[x] = i;
				dfs(x+1);
				visit[i] = 0;			}
		}
	}
}

上面贴出的代码一直不能AC，希望大神指点迷津。

8.剪格子

问题描述

如下图所示，3 x 3 的格子中填写了一些整数。

     +--*--+--+ 
    
|10* 1|52| 
    
+--****--+ 
    
|20|30* 1| 
    
*******--+ 
    
| 1| 2| 3| 
    
+--+--+--+

我们沿着图中的星号线剪开，得到两个部分，每个部分的数字和都是60。

本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。

如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。

如果无法分割，则输出 0。

输入格式

程序先读入两个整数 m n 用空格分割 (m,n<10)。

表示表格的宽度和高度。

接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。