2015 蓝桥杯 JavaB组省赛

忘是亡心i 2022-06-18 10:49 275阅读 0赞

*   *   *  1. 三角形面积
         *  2. 立方变自身
         *  3. 三羊献瑞
         *  4. 循环节
         *  5. 九数组分数
         *  6. 加法变乘法
         *  7. 牌型种数
         *  8. 饮料换购
         *  9. 垒骰子
         *  10. 生命之树

--------------------

### 1. 三角形面积 ###

![20170405125450102][]

图中的所有小方格面积都是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. 三羊献瑞 ###

观察下面的加法算式：

![三羊献瑞][SouthEast]

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

请你填写“三羊献瑞”所代表的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][b] =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中的点所对应的整数的和尽量大。  
这个最大的和就是上帝给生命之树的评分。

经过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

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

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[n].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]);  
                }  
            }  
        }  
    }

[20170405125450102]: /images/20220618/dde32f8e1da549d596bc6d51c17cc858.png
[SouthEast]: /images/20220618/7378211b32ba48b88c0611f0e29c9310.png