2015 蓝桥杯 JavaB组 省赛

1. 三角形面积

2. 立方变自身

3. 三羊献瑞

4. 循环节

5. 九数组分数

6. 加法变乘法

7. 牌型种数

8. 饮料换购

9. 垒骰子

10. 生命之树

1. 三角形面积

图中的所有小方格面积都是1。

那么，图中的三角形面积应该是多少呢？

请填写三角形的面积。不要填写任何多余内容或说明性文字。

博主有话说

可以直接确定3条边的边长，然后用海伦公式。

也可以用外接矩形的面积减去3个直角三角形的面积。这种算法很容易，口算即可。

填空答案

28

2. 立方变自身

观察下面的现象,某个数字的立方，按位累加仍然等于自身。

1^3 = 1

8^3 = 512 5+1+2=8

17^3 = 4913 4+9+1+3=17

…

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

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

博主有话说

这个数字不可能很大，我们很容易确定范围（假设每个位都是9，其立方增长很快就超过了诸位和的增长）

填空答案

6

public class Main{
public static void main(String[] args) {
int k = 0;
for(int i = 1;i<100000;i++){
long temp = (long)Math.pow(i, 3);
long sum = 0;
while(temp != 0){
sum += temp%10;
temp /= 10;
}
if(sum == i){
k++;
}

}
System.out.println(k);
}
}

3. 三羊献瑞

观察下面的加法算式：



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

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

博主有话说

使用DFS遍历即可

填空答案

1085

public class Main {
static int[] a = new int[8];
static int[] visited = new int[10];

public static void main(String[] args) {
dfs(0);
}

static void dfs(int k) {
if (k == a.length) {
if (a[0] == 0 || a[4] == 0)
return;
int m = a[0] * 1000 + a[1] * 100 + a[2] * 10 + a[3];
int n = a[4] * 1000 + a[5] * 100 + a[6] * 10 + a[1];
int r = a[4] * 10000 + a[5] * 1000 + a[2] * 100 + a[1] * 10 + a[7];
if (m + n == r)
System.out.println(n);
} else {
for (int i = 0; i < visited.length; i++) {
if (visited[i] == 1)
continue;
a[k] = i;
visited[i] = 1;
dfs(k + 1);
visited[i] = 0;
}
}
}
}

4. 循环节

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。

比如，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)

5. 九数组分数

1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？

下面的程序实现了该功能，请填写划线部分缺失的代码。

public class A
{
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(a*3==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};
f(x,0);
}
}

注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

填空答案

{int t=x[k]; x[k]=x[i]; x[i]=t;}

6. 加法变乘法

我们都知道：1+2+3+ … + 49 = 1225

现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：

1+2+3+…+10*11+12+…+27*28+29+…+49 = 2015

就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

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

博主有话说

两重循环，逐一实验改为乘号的位置就可以了。

可以使用的技巧是：不必逐一算式，加法、乘法地验证答案。

设在第i项后改，则：

… + i + (i+1) + …

改为：+ i * (i+1) + …

应该比原来增大了： i*i-i-1 这么多。可以快速算出整个算式的结果。

填空答案

16

程序

public class Main{
public static void main(String[] args) {
for(int i = 2;i <= 49 ; i++){
int temp = 1225 - i - (i-1) + i*(i-1);
for(int j = i+2;j <= 49; j++){
int tempA = temp - j - (j-1) + j*(j-1);
if(tempA == 2015)
System.out.println(i-1);
}
}
}
}

7. 牌型种数

小明被劫持到X赌城，被迫与其他3人玩牌。

一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。

这时，小明脑子里突然冒出一个问题：

如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

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

填空答案

359810

public class Main{
static int sum,count;
public static void main(String[] args) {
dfs(0);
System.out.println(count);
}
private static void dfs(int k) {
if(k>13 || sum>13)
return;
if(k==13&&sum==13){
count++;
return;
}

for(int i=0;i<5;i++){
sum += i;
dfs(k+1);
sum -= i;
}
}
}

8. 饮料换购

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。

输入

一个整数n，表示开始购买的饮料数量（0 < n < 10000）

输出

一个整数，表示实际得到的饮料数

例如：

用户输入

100

程序输出

149

用户输入

101

程序输出

151

资源约定

峰值内存消耗（含虚拟机） < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

import java.util.Scanner;

public class Main{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int num = s.nextInt();
int result = num;
while(num/3 != 0){
int temp = num/3;
result += temp;
num = num%3 + temp;
}
System.out.println(result);
}
}

9. 垒骰子

赌圣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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

import java.util.Scanner;

public class Main {
static Scanner in = new Scanner(System.in);
static int n, m;
static int[][] oje = new int[7][7];
static int count = 0;
static int[] dui = {0, 4, 5, 6, 1, 2, 3};
static int BigInt = 1000000007;
public static void main(String[] args) {
n = in.nextInt(); m = in.nextInt();
int a, b;
for (int i = 0; i < m; i++) {
a = in.nextInt(); b = in.nextInt();
oje[a] =1;
oje[b][a] = 1;
}

dfs(0, -1);
int ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans*4)%BigInt;
}
System.out.println((count*ans)%BigInt);
}

private static void dfs(int i, int di) {
if(i==n) {
count++;
if(count>BigInt) count -= BigInt;
} else {
if(di==-1) {
for (int j = 1; j < 7; j++) {
dfs(i+1,dui[j]);
}
} else {
for (int j = 1; j < 7; j++) {
if(oje[j][di]==0) {
dfs(i+1, dui[j]);
}
}
}
}
}
}

10. 生命之树

在X森林里，上帝创建了生命之树。

他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。

上帝要在这棵树内选出一个非空节点集S，使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, …, vk, b} 使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。

在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。

de45

这个最大的和就是上帝给生命之树的评分。

经过atm的努力，他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm 不擅长计算，他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。

[b]输入格式

第一行一个整数 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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

import java.util.Scanner;
import java.util.Vector;

public class Main {

static class Node{
//每个节点的值
int val;
//储存每个点的邻接点
Vector<Integer> vector = new Vector<Integer>();
//dp[0],dp[1]分别代表这个点选择，不选择
int dp[] = new int[2];
//是否访问过
boolean visit = false;
}

static Node node[];
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
node = new Node[N+1];
for (int i = 1; i < node.length; i++) {
int value = input.nextInt();
node[i] = new Node();
node[i].dp[0] = 0;
node[i].dp[1] = value;
node[i].val = value;
}

for (int i = 1; i < node.length-1; i++) {
int m = input.nextInt();
int n = input.nextInt();
//储存邻接表
node[m].vector.add(n);
node
.vector.add(m);
}

dfs(1);
int ans = Math.max(node[1].dp[0], node[1].dp[1]);
System.out.println(ans);
}
private static void dfs(int num) {
node[num].visit = true;
int sum = node[num].vector.size();
for (int i = 0; i < sum; i++) {
int son = node[num].vector.get(i);
if (node[son].visit==false) {
dfs(son);
node[num].dp[1] += Math.max(node[son].dp[0], node[son].dp[1]);
}
}
}
}