第六届蓝桥杯软件类省赛题解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
#include
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
#include
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
答：模拟一下就行了吧应该，代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#include
#include
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
#include
#include
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
#include
#include
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;
}
|