2016年第七届蓝桥杯省赛C /C++ A组 1~8题题解

最新推荐文章于 2021-05-18 23:12:39 发布
最新推荐文章于 2021-05-18 23:12:39 发布
阅读量831 收藏 2
点赞数
分类专栏： 全排列 文章标签： 蓝桥杯

部分转载自：http://blog.csdn.net/idealism_xxm/article/details/50937688

还有：http://blog.csdn.net/summonlight/article/details/61427968

题目连接：http://www.doc88.com/p-7886959785035.html


3.填格子 （DFS）

有一个含有10个格子的图形，现用0~9填充，连续的数不能填充在相邻的格子中（包

括对角线相邻），问有多少种填充方法？


我认为每个数字只能填一次，算出来是：1580

用的方法是全排列，可以用库函数next_permutation解决。

代码如下：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>


using namespace std;
int num[10] = {}, cnt = 0, maps[9][9] = {};
int nextr[4] = {0, -1, -1, -1};
int nextc[4] = {-1, -1, 0, 1};
bool check(int row, int column, int number)
{
    for(int i = 0; i < 4; i++)
    {
        int rr = row + nextr[i];
        int cc = column + nextc[i];
        if(abs(maps[rr][cc] - number) <= 1) return false;
    }
    return true;
}
void dfs(int num[])
{
    int cc = 1, rr = 1, i;
    for(i = 0; i <= 9; i++)
    {
        cc++;
        if(cc > 4)
        {
            rr++;
            cc = 1;
        }
        maps[rr][cc] = num[i];
        if(!check(rr, cc, num[i]))
        {
            break;
        }
    }
    if(i > 9) cnt++;
}
int main(void)
{
    long long counter = 0;
    for(int i = 0; i < 7; i++)
    {
        for(int j = 0; j < 7; j++)
        {
            maps[i][j] = -6;
        }
    }
    for(int i = 0; i <= 9; i++)
    {
        num[i] = i;
    }
    do{
        dfs(num);
        counter++;
    }while(next_permutation(num, num + 10));
    cout << cnt << endl;
    return 0;
}

4.就是快排代码

5.  x&(x + 1)

模拟一下就能出结果了

6. 

答案：64

这里有个250秒出结果的代码：

#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
int num[15] = {}, cnt = 0;


void dfs(int num[])
{
    if(num[1] + num[2] == num[3])
    {
        if(num[4] - num[5] == num[6])
        {
            if(num[7] * num[8] == num[9])
            {
                if(num[10] == num[11] * num[12])
                {
                    cnt++;
                }
            }
        }
    }
}
int main()
{
    for(int i = 1; i <= 13; i++)
    {
        num[i] = i;
    }
    do{
        dfs(num);
    }while(next_permutation(num + 1, num + 14));
    printf("%d\n", cnt);
    return 0;

}


改进后的代码：（总之就是要仔细），优化的方面：每个等式的结果是不用枚举的，

只要判断能否算出结果和是否有重复结果即可。该代码可一秒算出结果。

#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;


int num[15] = {}, cnt = 0;
bool book[15] = {};


void dfs(int step)
{
    if(step == 3)
    {
        if(num[1] % num[2] == 0 && num[1] > num[2] && !book[num[1] / num[2]])
        {
            book[num[1] / num[2]] = true;
            dfs(4);
            book[num[1] / num[2]] = false;
        }
        return;
    }
    if(step == 6)
    {
        if(num[4] * num[5] <= 13 && !book[num[4] * num[5]])
        {
            book[num[4] * num[5]] = true;
            dfs(7);
            book[num[4] * num[5]] = false;
        }
        return;
    }
    if(step == 9)
    {
        if(num[7] + num[8] <= 13 && !book[num[7] + num[8]])
        {
            book[num[7] + num[8]] = true;
            dfs(10);
            book[num[7] + num[8]] = false;
        }
        return;
    }
    if(step == 12)
    {
        if(num[10] + num[11] <= 13 && !book[num[10]+ num[11]])
        {
            cnt++;
        }
        return;
    }
    for(int i = 1; i <= 13; i++)
    {
        if(!book[i])
        {
            num[step] = i;
            book[i] = true;
            //if(step == 3 || step == 6 || step == 9 || step == 12) printf("%d\n", num[i]);
            dfs(step + 1);
            book[i] = false;
        }
    }
}
int main()
{
    dfs(1);
    cout << cnt << endl;
    return 0;
}


7.  深度优先搜索（有点像走迷宫）

以邮票的每一个格子为起点列举不同的走法（每次走的都是相邻的格子），并记录所

走过的格子，走到第五个格子就终止本次“行走”，然后对那五个格子的坐标进行从

小到大排序，再跟之前记录的走法进行配对，若没有重复，则记录该走法，最终得出结果。

错误代码（我都不知道为啥会同一个格子走两次，醉了，咋改都不对）：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct Node
{
    pair<int, int>rc[5];
    bool operator == (const Node &a) const
    {
        for(int i = 0; i < 5; i++)
        {
            if(rc[i].first != a.rc[i].first || rc[i].second != a.rc[i].second)
                return false;
        }
        return true;
    }
};
vector<Node>book;
int nextc[4] = {-1, 0, 1, 0}, ans = 0;
int nextr[4] = {0, -1, 0, 1};
bool vis[5][5] = {};
bool check1(int a, int b)
{
    if(0 <= a && a < 3 && 0 <= b && b < 4) return true;
    else return false;
}
bool check2(Node a)
{
    for(int i = 0; i < book.size(); i++)
    {
        int j;
        for(j = 0; j < 5; j++)
        {
            if(book[i].rc[j].first != a.rc[j].first || book[i].rc[j].second != a.rc[j].second)
            {
                break;
            }
            if(j > 0 && (a.rc[j].first == a.rc[j - 1].first) && (a.rc[j].second == a.rc[j - 1].second))
                return false;
        }
        if(j >= 5) return false;
    }
    return true;
}
void dfs(Node st, int step)
{
    if(step == 5)
    {
        Node rep;
        for(int i = 0; i < 5; i++)
        {
            rep.rc[i].first = st.rc[i].first;
            rep.rc[i].second = st.rc[i].second;
        }
        sort(rep.rc, rep.rc + 5);
        if(check2(rep))
        {
            ans++;
            cout << ans << endl;
            for(int i = 0; i < 5; i++)
            {
                cout << st.rc[i].first << "  " << st.rc[i].second << "  ";
            }
            cout << endl;
            book.push_back(rep);
        }
    }
    for(int j = 0; j < 4; j++)
    {
        int rr = st.rc[step - 1].first + nextr[j];
        int cc = st.rc[step - 1].second + nextc[j];
        //cout << "one  " << step << "  " << rr << "  "<< cc << endl;
        if(check1(rr, cc) && !vis[rr][cc])
        {
            if(rr == st.rc[step - 1].first && cc == st.rc[step - 1].second)
                cout << "****  " << rr << "  " << cc << endl;
            //cout << "two  " << step << "  " << rr << "  " << cc << endl;
            vis[rr][cc] = true;
            st.rc[step].first = rr;
            st.rc[step].second = cc;
            dfs(st, step + 1);
            vis[rr][cc] = false;
            st.rc[step].first = -1;
            st.rc[step].second = -1;
        }
    }
}
int main()
{
    Node st;
    for(int i = 0; i < 3; i++)
    {
        st.rc[0].first = i;
        for(int j = 0; j < 4; j++)
        {
            //cout << i << "  " << j << endl;
            st.rc[0].second = j;
            vis[i][j] = true;
            dfs(st, 1);
            vis[i][j] = false;
        }
    }
    printf("#####\n");
    cout << ans << endl;
    int nn = 0;
    for(int i = 0; i < book.size(); i++)
    {
        for(int j = 0; j < 5; j++)
        {
            if(j > 0 && book[i].rc[j].first == book[i].rc[j - 1].first && book[i].rc[j].second == book[i].rc[j - 1].second)
            {
                cout << "***" << endl;
                nn--;
            }
            cout << book[i].rc[j].first << "  " << book[i].rc[j].second << "  ";
        }
        nn++;
        cout << endl;
    }
    cout << nn << endl;

}


正确代码：

#include<cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
///num数组负责记录第1~5步的格子，rc数组负责记录12个格子的坐标，cnt负责记录步法种数
int num[10] = {}, rc[13][3] = {}, cnt = 0;
///book数组负责记录格子是否被走过
bool book[6][6] = {};
int cal(int xx, int yy)
{
    if(!book[xx][yy]) return 0;
    book[xx][yy] = 0;
    return 1 + cal(xx - 1, yy) + cal(xx + 1, yy) + cal(xx, yy - 1) + cal(xx, yy + 1);
}
void dfs(int number, int step)
{
    if(step == 5)
    {
        ///memset要放最前面
        memset(book, false, sizeof(book));
        for(int i = 0; i < 5; i++)
        {
            book[rc[num[i]][0]][rc[num[i]][1]] = true;
        }
        if(cal(rc[number][0], rc[number][1]) == 5) cnt++;
        return;///千万别忘了这个
    }
    for(int i = number + 1; i <= 12; i++)
    {
        num[step] = i;
        dfs(i, step + 1);
        num[step] = -1;
    }
}
int main(void)
{
    ///i，j定义初始为 1 是为了cal函数的 xx-1 和 yy-1
    for(int i = 1, n = 1; i <= 3; i++)
    {
        for(int j = 1; j <= 4; j++, n++)
        {
            rc[n][0] = i;
            rc[n][1] = j;
        }
    }
    dfs(0, 0);
    cout << cnt << endl;
    return 0;
}


8.emmm，就是优化的暴力枚举了，主要优化枚举时的下限和上限，不要怕超时。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;


int a[5];
void cal(int num)
{
    int maxx[5];
    maxx[1] = (int)(sqrt((double)(num) / 4)) + 1;
    for(a[1] = 0; a[1] <= maxx[1]; a[1]++)
    {
        int max1 = num - a[1]*a[1];
        if(max1 > 0)
        {
            maxx[2] = (int)(sqrt((double)(max1) / 3)) + 1;
            for(a[2] = a[1]; a[2] <= maxx[2]; a[2]++)
            {
                int max2 = max1 - a[2]*a[2];
                if(max2 > 0)
                {
                    maxx[3] = (int)(sqrt((double)(max2) / 2)) + 1;
                    for(a[3] = a[2]; a[3] <= maxx[3]; a[3]++)
                    {
                        int k = max2 - a[3]*a[3];
                        a[4] = (int)sqrt((double)(k));
                        if(k > 0 && k == a[4] * a[4] && a[4] >= a[3])
                        {
                            return;
                        }
                    }
                }
            }
        }
    }
}
int main()
{
    int num;
    while(cin >> num)
    {
        cal(num);
        cout << a[1] << " " << a[2] << " " << a[3] << " " << a[4] << endl;
    }

}

算法好难呀
关注
专栏目录
2020年 第11届 蓝桥杯 C/C++ B组 省赛真题详解及小结【第1场省赛2020.7.5】【Java版】
upward
08-26 6355
一、试题 A: 跑步训练 方法一 方法二 二、试题 B: 纪念日 方法一：使用“计算器”求解 方法二：使用“日期类”求解（SimpleDateFormat+Date） 方法三：使用“日期类”求解（Date） 三、试题 C: 合并检测 四、试题 D: REPEAT 程序 五、试题 E: 矩阵 六、试题 F: 整除序列 解法一：ArrayList 解法二：快速位运算 七、试题 G: 解码 解法一：替换字符 解法二：boolean isDigit(char ch) 八、试题 H: 走方格 九、试题 I: 整数..
2016年省赛第七届蓝桥杯B组C/C++第六题解 方格填数
Rlynn的博客
10-08 320
第六题：方格填数 如下的10个格子 填入0~9的数字。要求：连续的两个数字不能相邻。 （左右、上下、对角都算相邻） 一共有多少种可能的填数方案？ 请填写表示方案数目的整数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 答案：1580 方法： 1、深搜 2、next_pern ...
2016年第七届蓝桥杯省赛(C/C++ A组)
idealism_xxm的专栏
03-20 6926
父亲和儿子 枚举 生日蜡烛 枚举 填格子 DFS 快速排序 去掉尾1 四则运算 DFS 剪邮票 DFS 四方定理 枚举 回文串 区间DP 区间DP 最小回文代价经典例题 最大公比
【快速排序】（2016）第七届蓝桥杯省赛 C/C++ A组 题解（第四题）
荷叶田田
03-20 500
第三题 题目    快速排序    排序排序在各种场合经常被用到。    快速排序是十分常用的高效率的算法。    其思想是：先选一个“标尺”，    用它把整个队列过一遍筛子，   以保证：其左边的元素都不大于它，其右边的元素都不小于它。   这样，排序问题就被分割为两个子区间。   再分别对子区间排序就可以了。   下面的代码是一种实现，请分析并填写划线部分缺少的代码。#include &lt...
蓝桥杯 2016c/c++A组 题解
趁着这大好时光，多看看。
03-22 6061
2016 蓝桥杯 第七届 c/c++ A组 第一题 网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 思路:拆分十
第七届蓝桥杯c语言a组答案,第七届蓝桥杯 C语言A组试题.pdf
weixin_42115513的博客
05-18 712
第七届蓝桥杯 C语言A组试题第七届蓝桥杯大赛个人赛省赛(软件类)C/C++ 大学A 组考生须知： 考试开始后，选手首先下载题目，并使用考场现场公布的解压密码解压试题。 考试时间为4 小时。时间截止后，提交答案无效。 在考试强制结束前，选手可以主动结束考试(需要身份验证)，结束考试后将无法继续提交或浏览答案。 选手可浏览自己已经提交的答案。被浏览的答案允许拷贝。 对同一题目，选手可多次提...
第七届蓝桥杯c语言a组答案,第七届蓝桥杯C语言B组题目总结
weixin_30838923的博客
05-18 423
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。(ps:式子是：a+b/c+m/n=10,其中，a,b,c都是一位数，m,n都是三位数。总共10个数字，并且这些数是1~9.不能重复)比如：6+8/3+952/714 就是一种解法，5+3/1+972/486 是另一种解法。这个算式一共有多少种解法？注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。解题思路：暴力枚举。a,b,...
2016第七届蓝桥杯C/C++ A组题解
Z0uY&z#1的博客
03-16 683
第一题 网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 7 第二题 生日蜡烛 某君从某年开始...
2016 第七届蓝桥杯 c/c++ B组省赛真题及解题报告
Void main with out return
03-20 7565
2016 第七届蓝桥杯 c/c++ B组省赛真题及解题报告 1.煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余
跳蚱蜢】2017年第八届蓝桥杯【C/C++省赛A组】
07-22 636
有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。   我们把这些蚱蜢顺时针编号为 1~8，每只蚱蜢都可以跳到相邻的空盘中，   也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？   注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。 思路分析：从一个状态到另一个状态最少需要多少步骤，毫无疑问就是BFS问题。此题与人工智能中的经典问题–八数码问
2016年省赛第七届蓝桥杯B组C/C++第一题解 煤球数量
Rlynn的博客
10-07 165
标题:煤球数量 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 答案：171700 #include<iostream> using namespace std; int main(){ int t=0,sum=0; for(int i=1;i<=100;
第8届蓝桥杯省赛题解（C/C++B组）
03-13
第8届蓝桥杯省赛题解（C/C++B组），自己总结，有详细指出，且提交通过。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
2016第七届蓝桥杯javaA组省赛题解
Zun
01-30 466
第七届蓝桥杯javaA组省赛题解 1.煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 思路： 直接计算 public static void main(S...
第七届蓝桥杯大赛个人赛省赛C++ A组 题解+原题 （填空题）
无知的渣渣的博客
12-12 874
1.网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 i*10+j-j*10-i =27 9*i-9*j = 27 i-j = 3 答案:7 (30 41 52 63 74 85 96) 2.生日蜡烛 某君从某年开始每年都举
蓝桥杯第七届 省赛 c语言A组
路漫漫其修远兮，吾将上下而求索
03-08 734
第一题 网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 【思路】 写一个循环即可解决问题。 答案：7...
蓝桥杯第七届省赛C语言A组题解
热门推荐
KI的博客
05-10 8万+
写题解的目的是强迫自己搞懂往届省赛每一道真题！！！ T1:网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 思路：年龄都是两位数，暴力枚举即可： #include<bits/stdc++.h> using name
【简单题】（2016）第七届蓝桥杯省赛 C/C++ A组 题解（第一题和第二题）
荷叶田田
03-20 561
第一题 题目网友年龄某君新认识一网友。当问及年龄时，他的网友说：“我的年龄是个2位数，我比儿子大27岁,如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄”请你计算：网友的年龄一共有多少种可能情况提示：30岁就是其中一种可能哦.请填写表示可能情况的种数。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。思路分析直接暴力枚举，可能出现的个位数和十位数即可代码#include &l...
第七届蓝桥杯C/C++ A组省赛题解
志远的博客
03-28 1665
1.网友年龄某君新认识一网友。当问及年龄时，他的网友说：“我的年龄是个2位数，我比儿子大27岁,如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄”请你计算：网友的年龄一共有多少种可能情况？提示：30岁就是其中一种可能哦.请填写表示可能情况的种数。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。答案：7代码：#include &lt;iostream&gt; using na...
第七届蓝桥杯大赛个人赛省赛C/C++A组答案(除编程题)
Samzhu
03-21 412
1.网友年龄 某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄” 请你计算：网友的年龄一共有多少种可能情况？ 提示：30岁就是其中一种可能哦. 请填写表示可能情况的种数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 答案:7 (30 41 52 63 74 ...
2016年最新LeetCode题解及C++11/C++教程
"LeetCode.pdf"是一份关于LeetCode在线编程平台的更新资料，发布于2016年1月28日。该文档由作者soulmachine提供，包含了题解以及使用C++11语言解决LeetCode问题的方法。LeetCode是一个著名的编程练习网站，提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值