目录
第一题：三角形面积
题目描述：
如图1所示。图中的所有小方格面积都是1。
那么，图中的三角形面积应该是多少呢？
请填写三角形的面积。不要填写任何多余内容或说明性文字。
答案：28
第二题：立方变自身
题目描述
观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1
8^3 = 512 5+1+2=8
17^3 = 4913 4+9+1+3=17
…
请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？
请填写该数字，不要填写任何多余的内容或说明性的文字。
答案：6
分析：
直接暴力搜索，搜索的范围可以确定在100以内
static int ans=0;
public static void main(String[] args) {
for(int i=1;i<=100;i++) {
int b=i*i*i;
int k=0;
int sum=0;
while(b>0) {
sum+=b%10;
b/=10;
}
if(sum==i) {
//System.out.println(i+" "+i*i*i);
ans++;
}
}
System.out.println(ans);
}
第三题：三羊献瑞
题目描述
观察下面的加法算式：
祥 瑞 生 辉
+
三 羊 献 瑞
-------------
三 羊 生 瑞 气
(如果有对齐问题，可以参看【图1.jpg】)
其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。
请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。
答案：1085
分析
直接暴力枚举即可
由于不同的字代表的不同数字，所以可以分析到e为1
那么a+e>10 e=1 a=9 f=0
c+g>10 b+1=c
/* a b c d
* + e f g b
* --------------
* e f c b h
*
*e=1 a=9 f=0 g+c>10 b+1=c
*b c=b+1 d g h
*/
public static void main(String[] args) {
for(int b=2;b<9;b++) {
int c=b+1;
for(int d=2;d<9;d++) {
if(d==b||d==c)continue;
for(int g=2;g<9;g++) {
if(g==b||g==c||g==d)continue;
if(g+c<=10)continue;
int sum=9000+b*100+c*10+d+1000+g*10+b;
for(int h=2;h<9;h++) {
if(h==b||h==c||h==d||h==g) continue;
if(sum==(10000+c*100+b*10+h)) {
System.out.println("10"+g+b);
}
}
}
}
}
}
第四题：循环节长度
题目描述：
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，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)
需要注意的是，可能分析出来是要求v.size() 但是要记住减去n第一次出现的位置，因为可能从一开始不是循环的小数，比如0.001212121212，小数点后的两个0不是循环节。
第五题：九数组分数
题目描述
1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？
下面的程序实现了该功能，请填写划线部分缺失的代码。
public class Main{
public static void test(int[] x)
{
int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]10 + x[8];
if(a3==b) System.out.println(a + " " + b);
}
public static void f(int[] x, int k)
{
if(k>=x.length){
test(x);
return;
}
for(int i=k; i<x.length; i++){
{int t=x[k]; x[k]=x[i]; x[i]=t;}
f(x,k+1);
_______________________________________ // 填空
}
}
public static void main(String[] args)
{
int[] x = {1,2,3,4,5,6,7,8,9};
// 用数组x来保存这个分数
// 前四个是分子 后六个是分母
f(x,0);
}
}
注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。
答案：{ int t=x[k]; x[k]=x[i]; x[i]=t; }
考察全排列中的回溯，这个是固定模式
第六题：加法变乘法
题目描述：
我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+…+1011+12+…+2728+29+…+49 = 2015
就是符合要求的答案。
请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
注意：需要你提交的是一个整数，不要填写任何多余的内容。
答案：16
分析：
暴力搜索，枚举乘号的位置
输出为10 16，题上要求寻找另外一个答案，也就是16
public static void main(String[] args) {
int a=2015-1225;
//直接算差值
for(int i=1;i<=46;i++) {
for(int j=i+2;j<=48;j++) {
int b=i*(i+1)+j*(j+1)-(i+(i+1)+j+(j+1));
if(a==b) {
System.out.println(i);
}
}
}
//将加法变为乘法之后求和
/*
for(int i=1;i<=46;i++) {
for(int j=i+2;j<=48;j++) {
int sum=(i-1)*i/2+i*(i+1)+(i+j+1)*(j-i-2)/2+j*(j+1)+(51+j)*(48-j)/2;
if(sum==2015) {
System.out.println(i);
}
}
}*/
}
第七题：牌型种数
题目描述：
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。
答案：3598180
分析：
考察全排列的变种，13种牌，每一种牌可以选择取或者不取，每种牌有五种选择 0 1 2 3 4 取0次意思为不取这张牌
当手里的牌为13张时，即为一种组合
代码中k表示对每一种牌型逐步分配，当k大于13时，即对13种牌都分配完毕，这时就return结束递归 当手里的牌总数大于13时，不符合要求，要return
static int ans;
//k代表对每一种牌型逐步分配 cnt代表手里牌的数量
static void f(int k,int cnt) {
if(k>13||cnt>13)return;
if(cnt==13) {
ans++;
return;
}
for(int i=0;i<5;i++) {
f(k+1, cnt+i);
}
}
public static void main(String[] args) {
f(0,0);
System.out.println(ans);
}
第八题：饮料换购
题目描述：
乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。
请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。
输入：一个整数n，表示开始购买的饮料数量（0<n<10000）
输出：一个整数，表示实际得到的饮料数
例如：
用户输入：
100
程序应该输出：
149
用户输入：
101
程序应该输出：
151
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
分析：
有两种方法。
第一种：
考虑到开始时购买n瓶饮料，3个瓶盖可以换一瓶饮料，那么，每次换购之后，等于说每一轮的换购中，每三瓶要去掉两瓶，然后每一轮实际得到的饮料数要加上3 当手里饮料剩3瓶以下时，就不能换购了。
第二种：
假设开始购买n瓶饮料，则将n瓶饮料按照每三个瓶盖可以换一瓶的规则先把n瓶饮料兑换，则可以换到n/3 瓶饮料，但是这时，手里的饮料数不一定就是n/3 因为第一次兑换的时候，n有可能不能整除3 那么要把剩余的瓶数加到手里的饮料数当中，即
int a=n/3;
int sum=n+a;
int b=n-3*a;
a=a+b;
这个时候的a才是手里现在总共有的数量
然后按这个套路继续循环换购，当手里的数小于3时结束。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int ans=0;
while(n>=3) {
n-=2;
ans+=3;
}
ans+=n;
System.out.println(ans);
// int a=n/3;
// int sum=n+a;
// int b=n-3*a;
// a=a+b;
// while(a>=3) {
// int c=a-(a/3)*3;
// a=a/3;
// sum+=a;
// a=a+c;
// }
// System.out.println(sum);
}
第九题：垒骰子
题目描述：
赌圣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
「样例输出」
544
「数据范围」
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解决方案1（递归，只能解决一部分数据）：
用reverse来存储1 的对面是 4，2 的对面是 5，3 的对面是 6。
声明一个boolean类型的数组来记录每次输入的互斥现象
递归时，从最顶层开始逐步往下递归，每一次都判断6个点在上方的情况，如果遇到当前层的最上面的点数跟上一层最下面的点数互斥，那么就不考虑这种情况，直接continue
否则，就继续递归n-1层，当低轨道最底层时，因为在每一个点朝上的情况下，还有四种情况，即有四个面可以旋转。所以最底层递归时返回4。同理在判断最顶层时，要把f(up,n-1)乘以4
static int M=1000000007;
static long ans;
//用二维数组下标记录互斥的数据
static boolean[][] conflict=new boolean[7][7];
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n,m;
n=sc.nextInt();
m=sc.nextInt();
for(int i=0;i<m;i++) {
int x,y;
x=sc.nextInt();
y=sc.nextInt();
conflict[x][y]=true;
conflict[y][x]=true;
}
for(int up=1;up<=6;up++) {
ans=(ans+4*f(up,n-1))%M;
}
System.out.println(ans);
}
//设置1 2 3分别对应6 5 4
static int reverse(int k) {
switch(k) {
case 1:
return 6;
case 2:
return 5;
case 3:
return 4;
case 4:
return 3;
case 5:
return 2;
case 6:
return 1;
default:
return 0;
}
}
static long f(int up,int n) {
if(n==0) {
return 4;
}
long ans=0;
for(int upp=1;upp<=6;upp++) {
if(conflict[up][upp])continue;
ans=(ans+f(reverse(upp), n-1))%M;
}
return ans;
}
解决方案2（动态规划）：
分析
用递归的方法时，对于每种情况，其接下来的递归有很多种情况，如果n很大时，其递归的数据是很庞大的，时间效率很低，只能解决一小部分数据。
所以，在递归的基础上，可以用动态规划来进行优化。
声明一个二维数组, dp[2][7]
从第1层往上开始逐层判断。用dp[0][] dp[1][]不断的来进行迭代
比如第一层6个点都可以在上面 那么就记录dp[0][] 的下标为1 2 3 4 5 6
的位置为1
然后再判断第二层 在第二层时，用dp[1][] 来存储每个下标为1 2 3 4 5 6的位置上情况数，这里的下标代表这个点在骰子的最上面的情况。
对于第二层的每个点，都要在判断与下层最上面的那个点是否冲突的情况下进行累加，比如对于第二层最上面的点为1的情况下，如果1对面的点跟第一层最上方的点冲突，那么这种情况就不能要，第一层 1 2 3 4 5 6 为最上面的点这些都可以取，第二层如果只有1在最上面的情况下，与第一层最上点为2的情况冲突，那么此时更新dp[1][] 的下标为1 2 3 4 5 6的情况之后分别为 5 6 6 6 6 6 以此类推，进行迭代。
当dp已经算完最上面的一层，这个时候就要对数组的6个点进行累加，最后将这个累加和再乘以4的n次方就是最终的答案
为什么要乘以4的n次呢？
因为对于每次的某个点为上的情况，还有4种情况，即横着转，总共有四个面。
算4的n次方时可以用快速幂的方法。
static int M=1000000007;
static long ans;
//用二维数组下标记录互斥的数据
static boolean[][] conflict=new boolean[7][7];
static int[][] dp=new int[2][7];
//设置1 2 3分别对应6 5 4
static int reverse(int k) {
switch(k) {
case 1:
return 6;
case 2:
return 5;
case 3:
return 4;
case 4:
return 3;
case 5:
return 2;
case 6:
return 1;
default:
return 0;
}
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n,m;
n=sc.nextInt();
m=sc.nextInt();
for(int i=0;i<m;i++) {
int x,y;
x=sc.nextInt();
y=sc.nextInt();
conflict[x][y]=true;
conflict[y][x]=true;
}
//第一层 6个点都可以为最上面 把第一层的每个点初始化为1
for(int i=1;i<=6;i++) {
dp[0][i]=1;
}
int cur=0;
//迭代层数
for(int level=2;level<=n;level++) {
cur=1-cur;
//尝试将六个面放在当前一层朝上的方向
for(int j=1;j<=6;j++) {
dp[cur][j]=0;
//将与j不冲突的上一层的格子累加起来
for(int i=1;i<=6;i++) {
if(conflict[reverse(j)][i])continue;
dp[cur][j]=(dp[cur][j]+dp[1-cur][i])%M;
}
}
}
for(int i=1;i<=6;i++) {
ans=(ans+dp[cur][i])%M;
}
//快速幂，求4的n次方
long sum=1;
long tmp=4;
long p=n;
while(p!=0) {
if((p&1)==1)sum=(sum*tmp)%M;
tmp=(tmp*tmp)%M;
p>>=1;
}
ans=(ans*sum)%M;
System.out.println(ans);
}
解决方案3（用矩阵相乘的方法）
动态规划的方法虽然相比递归优化了很多，但是也只能跑60%的数据，对于10的9次方的数据，也会超时。
用矩阵相乘的方法主要思想就是先把相互冲突的数据存放到一个矩阵当中，然跟每层相乘，相乘之后再累加每个点在最上面的情况
更新矩阵 继续跟冲突矩阵相乘。
public class t9_垒骰子_最终版 {
static int M=1000000007;
static int[] op=new int[7];
static int n;
static int m;
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])%M;
}
}
//ans*4的n次方
System.out.println(ans*power(4,n)%M);
}
private static long power(long i, int n) {
long sum=1;
while(n!=0) {
if((n&1)==1)sum=(sum*i)%M;
i=(i*i)%M;
n>>=1;
}
return sum;
}
//矩阵的快速幂
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])%M;
}
}
}
return ans;
}
第十题：生命之树
题目描述
在X森林里，上帝创建了生命之树。
他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。
上帝要在这棵树内选出一个非空节点集S，使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, …, vk, b} 使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。
在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。
这个最大的和就是上帝给生命之树的评分。
经过atm的努力，他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm 不擅长计算，他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。
「输入格式」
第一行一个整数 n 表示这棵树有 n 个节点。
第二行 n 个整数，依次表示每个节点的评分。
接下来 n-1 行，每行 2 个整数 u, v，表示存在一条 u 到 v 的边。由于这是一棵树，所以是不存在环的。
「输出格式」
输出一行一个数，表示上帝给这棵树的分数。
「样例输入」
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5
「样例输出」
8
「数据范围」
对于 30% 的数据，n <= 10
对于 100% 的数据，0 < n <= 10^5, 每个节点的评分的绝对值不超过 10^6 。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解析：
考察无根树
用一个ArrayList数组来存放两个相连的树
static int n;
static List<Integer>[] g;
static long ans;
static long[] w;
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
w=new long[n+1];
g=new ArrayList[n+1];
//初始化g
initG();
for(int i=1;i<=n;i++) {
w[i]=sc.nextInt();
}
for(int i=0;i<n-1;i++) {
int a=sc.nextInt();
int b=sc.nextInt();
g[a].add(b);
g[b].add(a);
}
dfs(1,0);
System.out.println(ans);
}
//u作为根结点代表的子树有一个最大权和，存储在w[u]中
private static void dfs(int u, int fa) {
for(int i=0;i<g[u].size();i++) {
Integer child=g[u].get(i);
if(child==fa)continue;
dfs(child, u);
if(w[child]>0) {
w[u]+=w[child];
}
if(w[u]>ans)ans=w[u];
}
}
//因为g是对象数组，对象数组中的每个对象都要进行初始化
private static void initG() {
for(int i=0;i<n+1;i++) {
g[i]=new ArrayList<Integer>();
}
}
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
