第八届蓝桥杯c/c++B组决赛试题不完全题解

关注

原创最新推荐文章于 2026-03-31 09:00:29 发布 815 阅读 AI 写同款· GEO 优化 ›

2017年第八届蓝桥杯省赛B组 C/C++ 2017.4.8，第八届蓝桥杯初赛，时隔一月多，才写个题解，贼尴尬...这学期竞赛多，PAT，天梯赛初决赛，蓝桥杯初决赛，ACM省赛，加上课程也多，真是累成狗了，蓝桥初赛后就一直学习课程，和小伙伴一起准备ACM省赛，蓝桥有点耽搁，还有一星期，刷点题练练手感，巩固一下，迎战蓝桥决赛，千万保持好心态，毕竟人的精力有限，而且竞赛只是身外之物，对我自己而言，竞赛只是加分项，绝对不是决定未来读研，工作，发展阅读详情

36进制

对于16进制，我们使用字母A-F来表示10及以上的数字。

如法炮制，一直用到字母Z，就可以表示36进制。

36进制中，A表示10，Z表示35，AA表示370

你能算出 MANY 表示的数字用10进制表示是多少吗?

请提交一个整数，不要填写任何多余的内容（比如，说明文字）

答案：(15分)

这道题不需要写代码，拿个计算器算算就好了

磁砖样式

小明家的一面装饰墙原来是 3*10 的小方格。

现在手头有一批刚好能盖住2个小方格的长方形瓷砖。

瓷砖只有两种颜色：黄色和橙色。

小明想知道，对于这么简陋的原料，可以贴出多少种不同的花样来。

小明有个小小的强迫症：忍受不了任何2*2的小格子是同一种颜色。

（瓷砖不能切割，不能重叠，也不能只铺一部分。另外，只考虑组合图案，请忽略瓷砖的拼缝）

显然，对于 2*3 个小格子来说，口算都可以知道：一共10种贴法，如【p1.png所示】

但对于 3*10 的格子呢？肯定是个不小的数目，请你利用计算机的威力算出该数字。

注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）

答案：(47分)

这道题还是不水的，深搜来写，网上出现了三种答案，感觉这种是最靠谱的一种，思路是dfs枚举每个格子，然后枚举的放两种放法（横着，竖着），和两种颜色，整个格子都填充完后，看一下是否符合情况及不存在2x2的格子颜色相同，如果符合条件，那么还需要去重，可以用map映射记录状态，也可以将每个格子颜色代表的字符转成字符串存在set中最后输出set的大小，总之需要去重。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
typedef long long ll;
map<int,int>Hash;
int w = 3,h = 10;
int mp[5][15];
int ans = 0;
bool check(){//检查是不是存在2x2格子相同颜色
    for(int i = 1; i <= w; i++){
        for(int j = 1; j < h; j++){
            if(mp[i][j] == mp[i][j+1] && mp[i][j] == mp[i+1][j] && mp[i][j] == mp[i+1][j+1])
                return false;
        }
    }
    return true;
}
void dfs(int x,int y){
    if(mp[x][y] == -1){//如果这个格子是空的-1，就放瓷砖，两种方向两种颜色
        if(y + 1 <= h && mp[x][y+1] == -1){//如果横着放每次占两个
            for(int i = 0; i < 2; i++){//枚举放每种颜色的瓷砖
                mp[x][y] = mp[x][y+1] = i;
                dfs(x,y+1);//因为根据if判断条件，y一定是小于h的，最大h-1，所以递归下一个只有dfs(x,y+1)
                mp[x][y] = mp[x][y+1] = -1;//还原
            }
        }
        if(x + 1 <= w && mp[x+1][y] == -1){//如果竖着放
            for(int i = 0; i < 2; i++){//枚举两种颜色
                mp[x][y] = mp[x+1][y] = i;
                if(y == h) dfs(x+1,1);//这时候如果y是h要枚举下一行了从第一个开始，所以dfs(x+1,1)
                else dfs(x,y+1);//否则枚举右边一个格子
                mp[x][y] = mp[x+1][y] = -1;//还原
            }
        }
    }
    else{//如果这个格子被瓷砖占了
        if(x == w && y == h){//如果已经到了最后一块格子
            if(check()){//检查是否出现2x2的相同颜色的格子，如果符合
                int ret = 0,bit = 1;
                for(int i = 1; i <= w; i++){
                    for(int j = 1; j <= h; j++){
                        ret += mp[i][j] * bit;
                        bit *= 2;
                    }
                }//将这种状态记录下来，去重过程，当然也可以吧状态用string记录存在set中
                if(!Hash.count(ret)){//如果是新的状态，答案+1
                    Hash[ret] = 1;
                    ans++;
                }
            }
            return;
        }
        if(y == h) dfs(x+1,1);//其他情况就继续枚举下一个格子取填充
        else dfs(x,y+1);
    }
}
int main(){
    memset(mp,-1,sizeof(mp));
    dfs(1,1);//从1,1开始放
    printf("%d\n",ans);
    return 0;
}

希尔伯特曲线

希尔伯特曲线是以下一系列分形曲线 Hn 的极限。我们可以把 Hn 看作一条覆盖 2^n × 2^n 方格矩阵的曲线，曲线上一共有 2^n × 2^n 个顶点(包括左下角起点和右下角终点)，恰好覆盖每个方格一次。

Hn(n > 1)可以通过如下方法构造：

将 Hn-1 顺时针旋转90度放在左下角
将 Hn-1 逆时针旋转90度放在右下角
将2个 Hn-1 分别放在左上角和右上角
用3条单位线段把4部分连接起来

对于 Hn 上每一个顶点 p ，我们定义 p 的坐标是它覆盖的小方格在矩阵中的坐标(左下角是(1, 1)，右上角是(2^n, 2^n)，从左到右是X轴正方向，从下到上是Y轴正方向)，

定义 p 的序号是它在曲线上从起点开始数第几个顶点(从1开始计数)。

以下程序对于给定的n(n <= 30)和p点坐标(x, y)，输出p点的序号。请仔细阅读分析源码，填写划线部分缺失的内容。

#include <stdio.h>

long long f(int n, int x, int y) {
    if (n == 0) return 1;
    int m = 1 << (n - 1);
    if (x <= m && y <= m) {
        return f(n - 1, y, x);
    }
    if (x > m && y <= m) {
        return 3LL * m * m + f(n - 1,(25分) , m * 2 - x + 1); 
    }
    if (x <= m && y > m) {
        return 1LL * m * m + f(n - 1, x, y - m);
    }
    if (x > m && y > m) {
        return 2LL * m * m + f(n - 1, x - m, y - m);
    }
}

int main() {
	int n, x, y;
    scanf("%d %d %d", &n, &x, &y); 
    printf("%lld", f(n, x, y));

    return 0;
}

注意：只填写划线处缺少的内容，不要填写已有的代码或符号，也不要填写任何解释说明文字等。

Author: ijrys

Organization: 青岛大学

m+y-1

这道题的做法实际上就是要求当前层n的编号，我们先去找n-1层中的编号，那么假设我们找到n-1的编号怎么求n层的编号呢，当前层n的正方形可以分成4个等大的正方形，这四个等大正方形大小其实就是上一层n-1层的正方形的大小，这样思路就是先判断它在四个较小正方形的哪一个上，因为曲线会遍历到正方形内所有点（格子），所以他在哪个正方形，首先直接加上它之前那几个正方形的大小就好了，然后在递归的去求，在他所在的这一块正方形应该处于第几个位置，这样一直递归到n=0就返回1了，回溯回去就可以求出来了。

我们观察图1和图二会发现，从前一层到下一层的变化，左上和右上的图形没有变，那么对于这两个正方形，只看局域这部分他们的点的编号和前一层的点编号是一样的

1.如果所求点落在了左上的正方形，那么首先我们先加上左下角的正方形大小，因为下面的一定是全部经过了，然后+所求点在左上正方形的位置，因为是和前一层的正方形点排序一样所以穿进去的的坐标就是x不变，y减去左下的正方形边长，题目中

m=1<<（n-1）就是上一层的正方形的边长，所以传进去的坐标就是(x,y-m)

2.如果落在了右上的正方形，和1同理这样按照顺序它前面有两个完整的前一层的正方形了，就有2*m*m个，先加上，然后再算在右上正方形中的位置，传入的坐标就应该是(x-m,y-m)

3.如果是落在了左下呢，我们观察一下图，当前层左下正方形，和上一层的正方形的区别是不是沿主对角线反转了一下，也就是说，原来的x变成了y，原来的y变成了x，因为左下角的正方形就是第一个所以前面不用加东西，直接传入坐标（y,x）

4.看完了情况3，最后看右下角的正方形是不是就容易很多了，没错它是按照沿副对角线翻转了，那么这样我们要还原出之前的坐标的话首先前面三个完整的正方形，先加上，然后看坐标怎么求

看了这个图在顺着推一下估计就好理解多了吧

（m+1-y , 2 * m - x + 1）

#include <stdio.h>

long long f(int n, int x, int y) {    //（x，y）只是用来判断在哪部分
    if (n == 0) return 1;
    int m = 1 << (n - 1);
    if (x <= m && y <= m) {    //左下角 
        return f(n - 1, y, x);    //返回给上一层的是此点在此层的序号 
    }
    if (x > m && y <= m) {    //右下角 
        return 3LL * m * m + f(n - 1,m+1-y, 2 * m - x + 1); //  填空
    }
    if (x <= m && y > m) {    //左上角 
        return 1LL * m * m + f(n - 1, x, y - m);
    }
    if (x > m && y > m) {    //右上角 
        return 2LL * m * m + f(n - 1, x - m, y - m);
    }
}

int main() {
    int n, x, y;
    scanf("%d %d %d", &n, &x, &y); //n为2的指数,(x,y)为顶点坐标
    printf("%lld", f(n, x, y));

    return 0;
}
/*
得找出当前层的点对下一层相应点的映射关系
*/

发现环

小明的实验室有N台电脑，编号1~N。原本这N台电脑之间有N-1条数据链接相连，恰好构成一个树形网络。在树形网络上，任意两台电脑之间有唯一的路径相连。

不过在最近一次维护网络时，管理员误操作使得某两台电脑之间增加了一条数据链接，于是网络中出现了环路。环路上的电脑由于两两之间不再是只有一条路径，使得这些电脑上的数据传输出现了BUG。

为了恢复正常传输。小明需要找到所有在环路上的电脑，你能帮助他吗？

输入

第一行包含一个整数N。

以下N行每行两个整数a和b，表示a和b之间有一条数据链接相连。

对于30%的数据，1 <= N <= 1000

对于100%的数据, 1 <= N <= 100000， 1 <= a, b <= N

输入保证合法。

输出

按从小到大的顺序输出在环路上的电脑的编号，中间由一个空格分隔。

样例输入

样例输出

1 2 3 5

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include ，不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

思路是类似于拓扑排序，记录下每个点的度数，如果有分出来的一定有1度的，从一度的开始，不断删，删到不能删除为止，剩下的构成环，如果一开始就没有1度的点，那么所有点构成一个环

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 1e5+10;
int n;
int vis[maxn];
vector<int>G[maxn];
int degree[maxn];
int main(){
    memset(degree,0,sizeof(degree));
    memset(vis,0,sizeof(vis));
    cin >> n;
    for(int i = 0; i < n; i++){
        int a,b;
        cin >> a >> b;
        G[a].push_back(b);
        G[b].push_back(a);
        degree[b]++;
        degree[a]++;
    }
    queue<int>q;
    int flag = 0;
    for(int i = 1; i <= n; i++){
        if(degree[i] == 1){
            q.push(i);
            flag = 1;
        }
    }
    if(!flag){
        for(int i = 1; i <= n; i++){
            printf("%d%c",i,i == n ? '\n' : ' ');
        }
        return 0;
    }
    while(!q.empty()){
        int tmp = q.front();
        q.pop();
        vis[tmp] = 1;
        for(int i = 0; i < G[tmp].size(); i++){
            if(!vis[G[tmp][i]]){
                degree[G[tmp][i]]--;
                if(degree[G[tmp][i]] == 1)
                    q.push(G[tmp][i]);
            }
        }
    }
    vector<int>ans;
    for(int i = 1; i <= n; i++){
        if(!vis[i]) ans.push_back(i);
    }
    sort(ans.begin(),ans.end());
    for(int i = 0; i < ans.size(); i++){
        printf("%d%c",ans[i],i == ans.size()-1 ? '\n' : ' ');
    }
    return 0;
}

对局匹配

小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。

小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。

现在小明知道这个网站总共有N名用户，以及他们的积分分别是A1, A2, ... AN。

小明想了解最多可能有多少名用户同时在线寻找对手，但是系统却一场对局都匹配不起来(任意两名用户积分差不等于K)？

输入

第一行包含两个个整数N和K。

第二行包含N个整数A1, A2, ... AN。

对于30%的数据，1 <= N <= 10

对于100%的数据，1 <= N <= 100000, 0 <= Ai <= 100000, 0 <= K <= 100000

输出

一个整数，代表答案。

样例输入

10 0
1 4 2 8 5 7 1 4 2 8

样例输出

再比如，

样例输入

10 1
2 1 1 1 1 4 4 3 4 4

样例输出

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

这道题可以使用dp来做。

因为我们每次是要相差k，那么我们不妨把所有相邻k的放到一个分组里面，我们预处理每个数字出现的次数，然后做dp即可，dp[i]代表当前组内前i个里面能选的最大数量，转移方程为dp[i] = max(dp[i-1],dp[i-2]+num[group[i]])

这个方程怎么来的呢？

假设选取a为起点了有a, a+k , a+2k, a+3k, ……a+mk这是一个组

那么假设第i个我该看a+2k这个数了，那么i-1是a+k，我们知道因为相差不能为k如果我们选i-1，那么i这个数a+2k就不能选了，而如果我们选i-2，那么i这个数就可以选，我们要选最大的所以转移方程就是dp[i] = max(dp[i-1],dp[i-2]+num[group[i]])

那么结束后我们就得到了这个分组的最大个数maxj

同理我们选择下一个分组，前一个分组的数已经标记了不会再选择，所以下一分组和之前分组是不会有交集的，我们选出了

b,b+k,……b+mk，同理我们求出了最大个数maxjj

因为两个分组间的差距一定不是k所以每个分组的最大值直接相加就得到了最终的最大值，时间复杂度O（n）

特殊处理一下k为0的情况即可，有几个不同的数就能选择多少

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
int n,k,a[maxn],num[maxn],ans[maxn],dp[maxn],res;
bool vis[maxn];
int main(){
    memset(vis,false,sizeof(vis));
    scanf("%d%d",&n,&k);
    for(int i = 0; i < n; i++){
        scanf("%d",&a[i]);
        num[a[i]]++;//统计每个数字的个数
    }
    sort(a,a+n);
    if(k == 0){//k=0时，有几个不同的数就有多少个
        res = 1;
        for(int i = 1; i < n; i++){
            if(a[i] != a[i-1]) res++;
        }
        printf("%d\n",res);
        return 0;
    }
    res = 0;
    for(int i = 0; i < n; i++){//枚举每组的起点
        if(vis[a[i]]) continue;
        else{
            vis[a[i]] = 1;
            int cnt = 0;
            int now = a[i];
            ans[cnt++] = a[i];
            while(num[now+k] != 0){
                ans[cnt++] = now + k;
                vis[now+k] = 1;
                now = now + k;
            }
            memset(dp,0,sizeof(dp));
            dp[0] = num[ans[0]];
            dp[1] = max(num[ans[0]],num[ans[1]]);
            for(int i = 2; i < cnt; i++){
                dp[i] = max(dp[i-1],dp[i-2]+num[ans[i]]);
            }
            res += dp[cnt-1];
        }
        printf("%d\n",res);
    }
    return 0;
}

观光铁路

跳蚤国正在大力发展旅游业，每个城市都被打造成了旅游景点。

许多跳蚤想去其他城市旅游，但是由于跳得比较慢，它们的愿望难以实现。这时，小C听说有一种叫做火车的交通工具，在铁路上跑得很快，便抓住了商机，创立了一家铁路公司，向跳蚤国王请示在每两个城市之间都修建铁路。

然而，由于小C不会扳道岔，火车到一个城市以后只能保证不原路返回，而会随机等概率地驶向与这个城市有铁路连接的另外一个城市。

跳蚤国王向广大居民征求意见，结果跳蚤们不太满意，因为这样修建铁路以后有可能只游览了3个城市（含出发的城市）以后就回来了，它们希望能多游览几个城市。于是跳蚤国王要求小C提供一个方案，使得每只跳蚤坐上火车后能多游览几个城市才回来。

小C提供了一种方案给跳蚤国王。跳蚤国王想知道这个方案中每个城市的居民旅游的期望时间（设火车经过每段铁路的时间都为1），请你来帮跳蚤国王。

输入格式

输入的第一行包含两个正整数n、m，其中n表示城市的数量，m表示方案中的铁路条数。接下来m行，每行包含两个正整数u、v，表示方案中城市u和城市v之间有一条铁路。保证方案中无重边无自环，每两个城市之间都能经过铁路直接或间接到达，且火车由任意一条铁路到任意一个城市以后一定有路可走。

输出格式

输出n行，第i行包含一个实数ti，表示方案中城市i的居民旅游的期望时间。你应当输出足够多的小数位数，以保证输出的值和真实值之间的绝对或相对误差不超过1e-9。

样例输入

样例输出

3.333333333333
5.000000000000
3.333333333333
5.000000000000

样例输入

样例输出

10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000
10.000000000000