大一备战蓝桥杯二

最新推荐文章于 2024-05-12 12:20:31 发布

NoteLoopy

最新推荐文章于 2024-05-12 12:20:31 发布

阅读量1.1k

点赞数 3

本文链接：https://blog.csdn.net/weixin_45822638/article/details/104772321

版权

一：奖卷数目

有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。
虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。

请提交该数字（一个整数），不要写任何多余的内容或说明性文字。

代码解决：

#include<iostream>
#include<sstream>
#include<string>
using namespace std;
void i2s(int num, string& str) {
    stringstream ss;
    ss << num;
    ss >> str;
}
int main() {
    int ans = 0;
    for (int i = 10000; i <= 99999; ++i) {
        string s;
        i2s(i, s);
        if (s.find('4') == string::npos)ans++;
    }
    cout << ans << endl;
        return 0; 
}

问题解决：if里的判定find

二：星系炸弹

在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。
每个炸弹都可以设定多少天之后爆炸。
比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。
有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。
请填写该日期，格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19
请严格按照格式书写。不能出现其它文字或符号。

解决:用表格计算就可以；注意：闰年366天，2月有29天。

三：加法变乘法

我们都知道：1+2+3+ … + 49 = 1225 现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015 比如： 1+2+3+…+1011+12+…+2728+29+…+49 = 2015就是符合要求的答案。请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。注意：需要你提交的是一个整数，不要填写任何多余的内容。

代码：

#include<iostream>
using namespace std;
int main() {
    for (int i = 1; i <= 46; ++i) {
        for (int j = i + 2; j <= 48; ++j) {
            if (i + (i + 1) - (i + i + 1) + j * (j + 1) - (j + j + 1) == 2015 - 1225)
                cout << i << " " << j << endl;
        }
    }
}

问题：注意技巧

，通过上面两个等式，我们可以发现1225-（10+11）-（27+28）等于2015-（1011）-（2728），接下来通过两个for循环枚举即可。

四：牌型种数

小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。

#include<iostream>
using namespace std;
int ans;
void f(int k, int cnt) {
    if (cnt > 13 || k > 13)return;
    if (k == 13 && cnt == 13) {
        ans++;
        return;
    }
    for (int i = 0; i < 5; ++i) {
        f(k + 1, cnt + i);
    }
}
int main() {
    f(0, 0);
    cout << ans << endl;
    return 0;
}

问题：这个题和李白打酒其实是一样的思想，递归找种类。李白打酒在上一篇博客：备战蓝桥杯1
这种思想很OK

五：移动距离

X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3…
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）
输入为3个整数w m n，空格分开，都在1到10000范围内
w为排号宽度，m,n为待计算的楼号。
要求输出一个整数，表示m n 两楼间最短移动距离。
例如：
用户输入：
6 8 2
则，程序应该输出：
4
再例如：
用户输入：
4 7 20
则，程序应该输出：
5
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include ，不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。

代码：

#include<iostream>
using namespace std;
int main() {
    int w, m, n;
    cin >> w >> m >> n;
    int rm = m % w == 0 ? m / w : m / w + 1;
    int rn = n % w == 0 ? n / w : n / w + 1;
    int cm = 0;
    int cn = 0;
    if (rm % 2 == 0)cm = rm * w - m + 1;
    else cm = w - (rm * w - m);
    if (rn % 2 == 0)cn = rn * w - n + 1;
    else cn = w - (rn * w - n);
    cout << abs(cm - cn) + abs(rm - rn) << endl;
    return 0;
}

六：垒骰子

赌圣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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

part one:我想到的就只有递归。
本题：资源限制，递归是严重超时的所以只能得到三十分

#define MOD 100000007;
#include<iostream>
using namespace std;
int op[7];
int n, m;
bool conflict[7][7];
/*
上一层定义好了朝上的数字为up的情况下，垒好cnt个筛子的方案数
*/
long long int f(int up, int cnt) {
    if (cnt == 0)
        return 1;
    long long ans = 0;
    for (int upp = 1; upp <= 6; upp++) {
        if (conflict[op[up]][upp])continue; //判断是否是互相矛盾的
        ans =(ans+ f(upp, cnt - 1))%MOD;
    }
    return ans;
}
void init() {//对立面
    op[1] = 4;
    op[4] = 1;
    op[2] = 5;
    op[5] = 2;
    op[3] = 6;
    op[6] = 3;
}
int main() {
    init();
    cin >> n >> m;
    for (int i = 0; i < m; i++) {//输入相互矛盾的骰子
        int x, y;
        cin >> x >> y;
        conflict[x][y] = true;
        conflict[y][x] = true;
    }
    long long ans = 0;
    for (int up = 1; up <= 6; up++) {//先放置第一个骰子，确定第一个对里
       ans=(ans+4*f(up, n - 1))%MOD;   
    }
    cout << ans << endl;
    return 0;
}

使用矩阵快速幂解决：
快速幂：快速幂使用
 添加链接描述
矩阵：

#include<iostream>
#define il inline
#define pb push_back
#define fi first
#define se second
#define ms(_data,v) memset(_data,v,sizeof(_data))
using namespace std;
typedef long long ll;
const ll inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, pd[10];
//初始化矩阵的对立面
void init() {
    pd[1] = 4, pd[4] = 1;
    pd[2] = 5, pd[5] = 2;
    pd[3] = 6, pd[6] = 3;
}
//结构体，实现矩阵的乘法
struct matrix {
    int m[7][7];
    matrix() { ms(m, 0); }
    matrix operator *(const matrix& tp)const {
     matrix res;
        for (int i = 1; i <= 6; ++i) {
            for (int j = 1; j <= 6; ++j) {
                for (int k = 1; k <= 6; ++k) {
                    res.m[i][j] = (res.m[i][j] + m[i][k] * tp.m[k][j]) % mod;
                }
           }
        }
        return res;
    }
};
//快速幂
matrix matpow(matrix x, int n) {
    matrix ans;
    for (int i = 1; i <= 6; ++i) ans.m[i][i] = 1;
    while (n) {
        if (n & 1) ans = ans * x;
        x = x * x;
        n >>= 1;
    }
    return ans;
}
ll mpow(int x, int n) {
    ll ans = 1;
    while (n) {
        if (n & 1) ans = (ans * x) % mod;
        x = (x * x) % mod;
        n >>= 1;
    }
    return ans;
}
int main() {
    std::ios::sync_with_stdio(0);
    init();
    cin >> n >> m;
    int x, y;
   matrix a;
   //初始化矩阵为1
    for (int i = 1; i <= 6; ++i)
        for (int j = 1; j <= 6; ++j) a.m[i][j] = 1;
    //输入矛盾，把矛盾的设为0
    for (int i = 0; i < m; ++i) {
        cin >> x >> y;
        a.m[x][pd[y]] = 0;
        a.m[y][pd[x]] = 0;
    }
    //第一行到第n行
    matrix ta = matpow(a, n - 1);
    ll t = pow(4, n);
    ll res = 0;
    //快速幂得到最后
    for (int i = 1; i <= 6; ++i) {
        for (int j = 1; j <= 6; ++j) {
           res = (res + ta.m[i][j]) % mod;
        }
    }
    cout << (t * res) % mod << endl;
    return 0;
}

七：煤球数目

有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
…
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

代码：

#include<iostream>
using namespace std;
int main(){
int pre=1;
int plus=2;
long sum=1;
for(int k=2;k<=100;++k){
pre=pre+plus;
sum+=pre;
plus++;
}

cout<<sum<<endl;
}

八：生日蜡烛

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。现在算起来，他一共吹熄了236根蜡烛。请问，他从多少岁开始过生日party的？请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

代码

#include <iostream>
using namespace std;
int main() {
    int ans;
    for (int i = 1; i <= 100; i++) {
         ans = 0;
        for (int j = i; j <= 100; j++)
        {
            ans += j;
            if (ans == 236)cout << i;
        }
    }
}

九:凑算式

 B       DEF
A + — + -——— = 10
C GHI
这个算式中A_I代表19的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
这个题不多说了，直接暴力生成9的全排列然后去验证等式是否成立，只是验证的时候如果防止精度问题可以通分把除法变成乘法。

代码：
递归回溯全排列

#include<iostream>
#include <algorithm>
using namespace std;
int ans;
int a[] = { 1,2,3,4,5,6,7,8,9 };
bool check() {
    int x = a[3] * 100 + a[4] * 10 + a[5];
    int y = a[6] * 100 + a[7] * 10 + a[8];
    if ((a[1] * y + a[2] * x) % (y * a[2]) == 0 && a[0] + (a[1] * y + a[2] * x) / (y * a[2]) == 10)
        return true;
    return false;
}
/*
递归回溯生成全排列，适用于无重复元素的情况
*/
void f(int k) {
    if (k == 9) {//一种排列已经生成
        if (check())
            ans++; 
    }
    for (int i = k; i < 9; ++i) {
        {int t = a[i]; a[i] = a[k]; a[k] = t; }
        f(k + 1);//递归
        {int t = a[i]; a[i] = a[k]; a[k] = t; }//回溯
    }
}
int main() {
    f(0);
   cout << ans << endl;
}

递归回溯全排列：1：定义好的必须是有序的数列 2：无重复
代码二：
while全排列

#include<iostream>
#include <algorithm>
using namespace std;
int ans;
int a[] = { 1,2,3,4,5,6,7,8,9 };
bool check() {
    int x = a[3] * 100 + a[4] * 10 + a[5];
    int y = a[6] * 100 + a[7] * 10 + a[8];
    if ((a[1] * y + a[2] * x) % (y * a[2]) == 0 && a[0] + (a[1] * y + a[2] * x) / (y * a[2]) == 10)
        return true;
    return false;
}
int main() {
    do 
    {
       if( check())
           ans++;  
    } while (next_permutation(a, a + 9));
   cout << ans << endl;
}

两种排列方式都要掌握

十：方格填数

如下的标记y的10个格子，填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）一共有多少种可能的填数方案？（答案1580）

	y	y	y
y	y	y	y
y	y	y

#include<iostream>
#include <algorithm>
using namespace std;
int ans;
int a[] = { 1,2,3,4,5,6,7,8,9 };
int check() {
}
void f(int k) {
    if (k == 10) {//一种排列已经生成
        if (check()==1)
            ans++;
    }
    for (int i = k; i < 9; ++i) {
        {int t = a[i]; a[i] = a[k]; a[k] = t; }
        f(k + 1);//递归
        //回溯
        {int t = a[i]; a[i] = a[k]; a[k] = t; }//回溯
    }
}
int main() {
    f(0);
    cout << ans << endl;
}

递归回溯全排列

NoteLoopy

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
大一备战蓝桥杯二

一：奖卷数目有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。请提交该数字（一个整数），不要写任何多余的内容或说明性文字。代码解决：#include<i...
复制链接

扫一扫