由于时间有限，然后题目的难度并不是很大，基本上都是暴力枚举即可，所以在这里只列出部分代码以及题目~
目录
- 01三角形面积（结果填空3’）
- 02立方变自身（结果填空5’）
- 03三羊开泰（结果填空9’）
- 04循环节长度（代码填空11’）
- 05九数组分数（代码填空15’）
- 06加法变乘法（结果填空17’）
- 07牌型种数（结果填空21’）
- 08饮料换购（程序设计13’）
- 09垒骰子（程序设计25’）
- 10生命之树（程序设计31’）
01三角形面积（结果填空3’）
02立方变自身（结果填空5’）
观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1
8^3 = 512 5+1+2=8
17^3 = 4913 4+9+1+3=17
…
请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？
请填写该数字，不要填写任何多余的内容或说明性的文字。
- 暴力求解
- 改进，各位数求和可化为字符串后，sum+=s.charAt(i)-‘0’;
public class _02立方变自身 {
static boolean isItself(int m){
int a=m*m*m;
String s=String.valueOf(a);
int sum=0;
for(int i=0;i<s.length();i++) {
// sum+=a%10;
// a=a/10;
sum+=s.charAt(i)-'0';
}
if(sum==m)
return true;
return false;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int cnt=0;
for(int i=1;i<100000;i++) {
if(isItself(i)==true) {
System.out.println(i);
cnt++;
}
}
System.out.println(cnt);
}
}03三羊开泰（结果填空9’）
观察下面的加法算式：
其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。
请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。
- 暴力枚举if(x1==x2) contiue;
- 全排列
public class _03散养献瑞 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int []a={0,1,2,3,4,5,6,7,8,9};
dfs(a,0);
}
private static void dfs(int[] a, int m) {
// TODO Auto-generated method stub
if(m>10)
return;
if(m==10){//结束深搜
int x = 1000*a[0] + 100*a[1] + 10*a[2] + a[3];
int y = 1000*a[4] + 100*a[5] + 10*a[6] + a[1];
int z = 10000*a[4] + 1000*a[5] + 100*a[2] + 10*a[1] + a[7];
if(a[0]==0 || a[4]==0) //保证位数
return;
if(x+y==z)
System.out.println(x+"+"+y+"=="+z);
}
for(int i=m;i<10;i++) {
int t=a[i];
a[i]=a[m];
a[m]=t;
dfs(a, m+1);
t=a[i];
a[i]=a[m];
a[m]=t;
}
}
}04循环节长度（代码填空11’）
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153… 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。
请仔细阅读代码，并填写划线部分缺少的代码。
public static int f(int n, int m)
{
n = n % m;
Vector v = new Vector();
for(;;)
{
v.add(n);
n *= 10;
n = n % m;
if(n==0) return 0;
if(v.indexOf(n)>=0) _________________________________ ; //填空
}*答案： return v.size() - v.indexOf(n);
05九数组分数（代码填空15’）
06加法变乘法（结果填空17’）
我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+…+1011+12+…+2728+29+…+49 = 2015
就是符合要求的答案。
请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
- 仔细分析题目，发现可以直接枚举法解决问题，两重循环
public class _06加法变乘法 {
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 1; i < 46; i++) {
for (int j = i+2; j <48; j++) {
if((i*(i+1)-(i+i+1)+j*(j+1)-(2*j+1)==2015-1225))
System.out.println(i+" "+j);
}
}
}
}07牌型种数（结果填空21’）
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。
- 递归求解
- 好像可以又直接暴力枚举，用13个for循环解决问题，咱考试的时间还是非常充足的
public class _07牌型种类 {
static int ans = 0;
static int sum = 0;
static void dfs(int cur) //cur取牌的次数，sum手牌的总数
{
if (sum>13)return;
if (cur == 13){
if (sum == 13) ans++;
return;
}
for (int i = 0; i <= 4; i++){ //13种牌，每种有4张，有五种取法 取0，1，2，3，4张
sum += i;
dfs(cur + 1);
sum -= i; //还原
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
dfs(0);
System.out.println(ans);
}
}08饮料换购（程序设计13’）
乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。
请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。
输入：一个整数n，表示开始购买的饮料数量（0<n<10000）
输出：一个整数，表示实际得到的饮料数
例如：
用户输入：
100
程序应该输出：
149
用户输入：
101
程序应该输出：
151
import java.util.Scanner;
public class _08饮料换购_ {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int sum=n;
while(n>=3) {
sum+=n/3;
n=n%3+n/3;
}
System.out.println(sum);
}
}09垒骰子（程序设计25’）
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。
不要小看了 atm 的骰子数量哦～
「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。
「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。
「样例输入」
2 1
1 2
public class _09_垒骰子 {
static int op[] = new int[7];
private static int n;
private static int m;
private static final long MOD = 1000000007;
static void init() {
op[1] = 4;
op[4] = 1;
op[2] = 5;
op[5] = 2;
op[3] = 6;
op[6] = 3;
}
public static void main(String[] args) {
init();
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
long conflict[][] = new long[6][6];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
conflict[i][j]=1;
}
}
//建立冲突矩阵
for (int i = 0; i < m; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
conflict[op[a] - 1][b - 1] = 0;
conflict[op[b] - 1][a - 1] = 0;
}
// 求冲突矩阵的n-1次方
long[][] mPow_n_1 = mPow(conflict, n - 1);
//累加矩阵的每个元素
long ans = 0;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
ans = (ans + mPow_n_1[i][j]) % MOD;
}
}
//ans*4^n
System.out.println(ans * power(4, n) % MOD);
}
private static long power(long i, int n) {
long ans = 1;
while (n != 0) {
if ((n & 1) == 1) ans = (ans * i) % MOD;
i = i * i % MOD;
n >>= 1;
}
return ans;
}
/*矩阵的快速幂*/
private static long[][] mPow(long[][] conflict, int n) {
long[][] e = new long[6][6];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if (i == j) e[i][j] = 1;
else e[i][j] = 0;
}
}
while (n != 0) {
if ((n & 1) == 1) {
e = mMul(e, conflict);
}
conflict = mMul(conflict, conflict);
n >>= 1;
}
return e;
}
private static long[][] mMul(long[][] a, long[][] b) {
long[][] ans = new long[6][6];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 6; k++) {
ans[i][j] = (ans[i][j] + a[i][k] * b[k][j]) % MOD;
}
}
}
return ans;
}
}
