第六届蓝桥杯软件类省赛题解C++/Java

第六届蓝桥杯软件类省赛题解C++/Java

1[C++]、统计不含4的数字
统计10000至99999中，不包含4的数值个数。
答：暴力循环范围内所有数字判断一下就是了，答案是52488

1[Java]、三角形面积
图中的所有小方格面积都是1。 那么，图中的三角形面积应该是多少呢？
答：小学生题目吧，算一下就行了，略。

2[C++]、计算1千天后的日期
2014-11-09再过1000天是哪一日？
答：用Excel算，用代码注意一下细节，答案2017-08-05。

2[Java]、立方变自身
观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1
8^3  = 512    5+1+2=8
17^3 = 4913   4+9+1+3=17 ...
请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？
答：这种题不要想多了，估计一下（其实都不用估计），假设这个数有3位数，那么它的立方的范围100^3~999^3为：[1000000,997002999]，这个范围内的数的各位和一定<81，因为就算每一位都是9，9位数最多81，怎么也不在[100,999]这个范围，同理，假设这个数有4位数，更不可能了。所以暴力测试一下1到100之间的数即可，最后满足条件的数有：1 8 17 18 26 27，共6个数

3、三羊献瑞
观察下面的加法算式：
祥 瑞 生 辉
+   三 羊 献 瑞
-------------------
三 羊 生 瑞 气
其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。
请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。
答：暴力测试一下所有可能的数就行了，答案好像是1085，代码实在太长，百度了一个：点这里。如果使用C++的next_permutation函数代码会变短很多。

4[C++]、古怪的星号修饰符
这是道代码填空题，主要是完成一个字符串s，按宽度width截断后，在固定宽度为width，两边为符号’|’的居中输出。
难点是题目给出了printf(“%*s%s%*s”,___)，要求填printf的实参列表。
答：题目找不到了，比如：printf(“%*s”, 6, “abc”) 就是把"abc"放到在域宽为6的空间中右对齐，*控制宽度。

4[Java]、循环节长度
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。 比如，11/13=6=>0.846153846153.....  其循环节为[846153] 共有6位。 下面的方法，可以求出循环节的长度。
请仔细阅读代码，并填写划线部分缺少的代码。

 

1 2 3 4 5 6 7 8 9 10 11

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) _______//填空          } }

答：看懂代码什么意思就很简单了。
if(n==0) return 0; 表示最后整除了，无循环节，当然这不是重点；
if(v.indexOf(n)>=0) 表示这次除法的余数以前出现过，所以出现了循环节，答案为return v.size()-v.indexOf(n)，注意没有加1，因为v.indexOf是从0开始的。

5、九数组分数
1,2,3...9 这九个数字组成一个分数，其值恰好为1/3，如何组法？
下面的程序实现了该功能，请填写划线部分缺失的代码。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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);     } }

答：Tips：这种递归代码一般都具有“对称性”，就像搜索的时候先标记再取消标记一样，所以答案为：{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和16，样例就是10，所以答案为16

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class Main {         public static boolean test(int i, int j) {          int m = i * (i + 1) + j * (j + 1);          int s = (49 + 1) * 49 / 2 - (2 * i + 1) - (2 * j + 1);          return m + s == 2015;         }         public static void main(String[] args) {          // 假设数字i后面的符号位第i个符号          for (int i = 1; i <= 46; i ++) {          for (int j = i + 2; j <= 48; j ++) {          if (test(i, j)) {          System.out.println(i);          }          }          }         } }

7、牌型种数
小明被劫持到X赌城，被迫与其他3人玩牌。 一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。 这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
答：题意：4个A 4个2..4个K共52张牌，取13张的方法数是多少？（我记得我当时题意都理解错了）
高中的排列组合吧，应该有数学方法可以直接算出来，如果不会（我也不会），看下面：
方法1：直接暴力搜索，对于每种牌，有5种可能，要么取1张，要么取2张..要么取4张，要么不取，中间也可以加一些剪枝，应该能跑出来吧...吧...
方法2：动态规划，dp[i][j]表示取到第i(1~13)种牌的时候已经有了j张牌的方法数
答案是：3598180

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <iostream> #include <cstdio> using namespace std; #define ll long long #define N 13   ll dp[N + 1][N + 1]; //取第i种牌时候已经有j张牌的方法数   int main() {     dp[0][0]  = 1;     for(int i = 1; i <= N; i ++) {         for(int j = 0; j <= N; j ++) {             if(j > 4 * i) break; //根本没那么多牌取             if(j >= 1) dp[i][j] += dp[i - 1][j - 1]; //第i种牌取1张             if(j >= 2) dp[i][j] += dp[i - 1][j - 2]; //第i种牌取2张             if(j >= 3) dp[i][j] += dp[i - 1][j - 3]; //第i种牌取3张             if(j >= 4) dp[i][j] += dp[i - 1][j - 4]; //第i种牌取4张             dp[i][j] += dp[i-1][j]; //第i种牌取0张         }     }     printf("%lld\n", dp[N][N]);     return 0; }

8[C++]、计算房子间曼哈顿距离
房子按S形摆放，如
1 2 3
6 5 4
7 8 …
现输入每行的宽度w，计算出任意两个房子m、n的曼哈顿距离（横向距离+竖向距离）。
答：很简单吧，不知道咋说

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream> #include <cmath> using namespace std;   void GetPos(int w, int n, int& x, int& y) {     x = (n - 1) / w + 1;     y = n % w;       if (y == 0) y = w;     if (x % 2 == 0) {         y = w - y + 1;     } } int main() {     int w, m, n;     int x1, y1, x2, y2;     cin >> w >> m >> n;     GetPos(w, m, x1, y1);     GetPos(w, n, x2, y2);     cout << abs(x1 - x2) + abs(y1 - y2) << endl;     return 0; }

8[Java]、饮料换购
乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。
请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。
输入：一个整数n，表示开始购买的饮料数量（0<n<10000）
输出：一个整数，表示实际得到的饮料数
答：模拟一下就行了吧应该，代码：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include <iostream> #include <cstdio> using namespace std;   int main() {     int n;     scanf("%d", &n);     int h = n, g = n; //h表示喝了的数量,g表示当前瓶盖数量     while(g >= 3) {         h += g / 3;         g = g/3 + g % 3;     }     printf("%d\n", h);     return 0; }

9、垒骰子
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！ 我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。 由于方案数可能过多，请输出模 10^9 + 7 的结果。
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36
答：矩阵快速幂，忘完了，代码仅供参考。
矩阵数组a[i][j]表示n个骰子堆起来，第一层顶面为i，第n层顶面为j的方案数（现在不考虑旋转）
初始化转换矩阵数组的时候注意：比如1和2不能挨着，要转换成1和5，因为2的对面是5
然后求得数组的n-1方，将所得矩阵每个数相加得到答案。
由于4个面可以旋转，所以将上面的答案乘以4^n。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

#include <iostream> #include <cstdio> #include <cstring> using namespace std; #define ll long long #define MOD 1000000007 #define N 6   struct Matric {     int sz;     int a[N][N];     Matric(int s, int k = 0) {         sz = s;         for(int i = 0; i < sz; i ++) {             for(int j = 0; j < sz; j ++) {                 a[i][j] = k;             }         }     }     Matric operator * (const Matric &t) {         Matric res = Matric(sz);         for(int i = 0; i < sz; i ++) {             for(int k = 0; k < sz; k ++) {                 if(a[i][k])                     for(int j = 0; j < sz; j ++) {                         res.a[i][j] += (ll)a[i][k] * t.a[k][j] % MOD;                     }             }         }         return res;     }     Matric operator ^ (int n) {         Matric ans = Matric(sz);         Matric tmp = *(this);         for(int i = 0; i < sz; i ++) ans.a[i][i] = 1;         while(n) {             if(n & 1) ans = ans * tmp;             tmp = tmp * tmp;             n >>= 1;         }         return ans;     }     int sum() {         int sum = 0;         for(int i = 0; i < sz; i ++) {             for(int j = 0; j < sz; j ++) {                 sum = (sum + a[i][j]) % MOD;             }         }         return sum;     } };   int pow(int a, int b) {     int ans = 1;     while(b) {         ans = ans * a % MOD;         if(b & 1) a = a * a % MOD;         b>>=1;     }     return ans; } int main() {     int n, m;     scanf("%d%d", &n, &m);     Matric a = Matric(6, 1);     while(m--) {         int u, v;         scanf("%d%d", &u, &v);         a.a[u - 1][(v + 2) % N] = 0;         a.a[v - 1][(u + 2) % N] = 0;     }     a = a ^ (n - 1);     int ans1 = a.sum();     int ans2 = pow(4, n);     int ans = (ll)ans1 * ans2 % MOD;     printf("%d\n", ans);     return 0; }

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 的边。由于这是一棵树，所以是不存在环的。
输出一行一个数，表示上帝给这棵树的分数。
答：题目有点绕啊，就是找一个点集，集合内两两可达，使得集合的和谐值最大。
树形DP：
dp[u][0]表示以u为根(不中u点)的子树的最大和谐值
dp[v][1]表示以u为根(选中u点)的子树的最大和谐值
状态转移方程：dp[u][0]=max(dp[v][0],dp[v][1]); //v为u的子节点
dp[u][1]+=max(dp[v][1],0) //a[u]为u点的和谐值

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

#include <iostream> #include <cstring> #include <cstdio> using namespace std; #define INF 0x3f3f3f3f #define N 100010   struct  Edge{     int to,next; }edge[N<<1];   int tot; int head[N];   int n; int a[N]; int dp[N][2];   void init() {     tot=0;     memset(head,-1,sizeof(head)); } void add(int u,int v) {     edge[tot].to=v;     edge[tot].next=head[u];     head[u]=tot++; } void dfs(int u,int pre) {     dp[u][0]=0;     dp[u][1]=a[u];     for(int i=head[u];i!=-1;i=edge[i].next){         int v=edge[i].to;         if(v!=pre){             dfs(v,u);             dp[u][0]=max(dp[u][0],max(dp[v][0],dp[v][1]));             dp[u][1]+=max(0,dp[v][1]);         }     } } int main() {     int mx=-INF;     scanf("%d",&n);     for(int i=1;i<=n;i++){         scanf("%d",&a[i]);         mx=max(a[i],mx);     }     init();     for(int i=1;i<n;i++){         int u,v;         scanf("%d%d",&u,&v);         add(u,v);         add(v,u);     }     if(mx<=0){         printf("%d\n", mx);         return 0;     }     dfs(1,1);     printf("%d\n",max(dp[1][0],dp[1][1]));     return 0; }