2020 7月蓝桥杯初赛 C++B组(详细解答）

试题 A: 跑步训练

本题总分：5 分
问题：
小明要做一个跑步训练。
初始时，小明充满体力，体力值计为 10000。如果小明跑步，每分钟损耗600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。
小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0，他就停止锻炼。
请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案。
答案中只填写数，不填写单位。

思路：直接计算即可，每两分钟消耗300体力，前60分钟都是跑一分钟休息一分钟，这是剩下的体力为400，不足以维持下一分钟消耗的600=能量，所以只能跑2/3分钟，也就是40秒，所以一共能锻炼32*120+40=3880秒

答案：3880

试题 B: 纪念日

本题总分：5 分
问题：
2020 年 7 月 1 日是中国某党成立 99 周年纪念日。
中国某党成立于 1921 年 7 月 23 日。
请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共含多少分钟？

思路： 直接用计算机上的日期计算器。

答案：36138 * 24*60=52038720

试题 C: 合并检测

本题总分：10 分
问题：
新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准 备给大量民众进病毒核酸检测。
然而，用于检测的试剂盒紧缺。 为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k 个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k 个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明 至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看， 如果检测前 k−1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中 不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用 了 k + 1 个试剂盒完成了 k 个人的检测。
A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能 最节省试剂盒？

思路：假设一共100个人，那么只有一个感染者，设一盒试剂可以检验k个人，那么100个人要的试剂的个数就是s=k+1+（100-k/k;
代码：

#include<bits/stdc++.h>
#include<bitset>
#include<unordered_map>
#define pb push_back
#define bp __builtin_popcount
using namespace std;
typedef  long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e6+1;
const int MOD=1e10;
const double PI=3.1415926535;
int lowbit(int x){return x&-x;}
ll gcd(ll x, ll y){ return y == 0 ? x : gcd(y, x%y); }
ll lcm(ll x, ll y){ return x / gcd(x, y)*y; }
inline ll dpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t) % MOD; b >>= 1; t = (t*t) % MOD; }return r; }
inline ll fpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t); b >>= 1; t = (t*t); }return r; }
int main()
{
    double mx = 1000.0;
    int c = 0;
    for (double i = 1; i <= 100;i++)
    {
        double t=(i + 1) + ceil((100 - i) / i);
        if(t<mx)
        {
            mx = t;
            c = i;
        }
    }
    cout << c << endl;
    system("pause");
    return 0;
}

试题 D: REPEAT 程序
本题总分：15 分
问题：
附件 prog.txt 中是一个用某种语言写的程序。
prog.txt 附件下载地址
其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达，从次行开始连续的缩进比该行多的（前面的空白更长的）为循环包含的内容。
例如如下片段：

A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的循环两次中。
REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
请问该程序执行完毕之后，A 的值是多少？

题目不是对图片上的式子进行计算，实际上的文件是很长的一串，要用字符串对计算过程进行模拟。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<bitset>
#include<vector>
#include<queue>
#include<stack>
#include<map>
using namespace std;
const int maxn = 1e5 + 100;
const int inf=0x3f3f3f3f;
typedef long long ll;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int a[maxn], b[maxn];
char str[1000];
int ans, now, p, w = 1;
int main()
{
    a[0] = -1;
    while(gets(str))
    {
        int len = strlen(str);
        p = 0;
        int i = 0;
        while (str[i++] == ' ')
            p++;
        while (p <= b[now])
            w /= b[now--];
        if (str[len-1]==':')
        {
            int k = str[len - 2] - '0';
            w *= k;
            now++;
            a[now] = p;
            b[now] = k;
        }
        else
        {
            int k = str[len - 1] - '0';
            ans += k * w;
        }
        
    }
    cout << ans << endl;
    system("pause");
    return 0;
}

E题空了补。

试题 F: 整除序列

时间限制: 1.0s 内存限制: 256.0MB 本题总分：15
问题：
有一个序列，序列的第一个数是 n，后面的每个数是前一个数整除 2，出这个序列中值为正数的项。

输入:
输入一行包含一个整数 n。

输出：
输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。

签到题。

#include<bits/stdc++.h>
using namespace std;

int main()
{
	long long n=0;
    scanf("%lld",&n);
	while(n)
	{
		printf("%lld ",n);
		n>>=1;
	}
    return 0;
}

试题 G: 解码

时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分
问题：
小明有一串很长的英文字母，可能包含大写和小写。
在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
现在给出简写后的字符串，请帮助小明还原成原来的串。

输入：
输入一行包含一个字符串。

输出：
输出一个字符串，表示还原后的串。

样例输入：
H3el5o2

样例输出：
HHHellllloo

评测用例规模与约定：
对于所有评测用例，字符串由大小写英文字母和数字组成，长度不100。
请注意原来的串长度可能超过 100。

思路：判断第i哥字符跟第i+1字符的关系，如果都是字母，输出第i个字符，如果前一个是字母，后一个是数字，安提议输出，最后再特判一下最后一个字符，如果是字母，那么输出它。
代码；

#include<bits/stdc++.h>
#include<bitset>
#include<unordered_map>
#define pb push_back
#define bp __builtin_popcount
using namespace std;
typedef  long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e6+1;
const int MOD=1e10;
const double PI=3.1415926535;
int lowbit(int x){return x&-x;}
ll gcd(ll x, ll y){ return y == 0 ? x : gcd(y, x%y); }
ll lcm(ll x, ll y){ return x / gcd(x, y)*y; }
inline ll dpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t) % MOD; b >>= 1; t = (t*t) % MOD; }return r; }
inline ll fpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t); b >>= 1; t = (t*t); }return r; }
int main()
{
    string str;
    cin >> str;
    for (int i = 0; i < str.size();i++)
    {
        if(isalpha(str[i])&&isdigit(str[i+1]))
        {
            for (int j = 1; j <= str[i + 1]-'0';j++)
                cout << str[i];
        }
        else if(isalpha(str[i])&&isalpha(str[i+1]))
        {
            cout << str[i];
        }
        
    }
    if(isalpha(str[str.size()-1]))
        cout << str[str.size() - 1];
        //system("pause");
    return 0;
}

试题 H: 走方格
时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分
问题：
在平面上有一些二维的点阵。这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下走。
注意，如果行号和列数都是偶数，不能走入这一格中。问有多少种方案。

输入：
输入一行包含两个整数 n, m。

输出：
输出一个整数，表示答案。

样例输入1：
3 4

样例输出1：
2

样例输入2：
6 6

样例输出2：
0

评测用例规模与约定：
对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
思路；简单的动规问题，初始化边界，找出来状态转移方程跑一遍即可。
代码：

#include<bits/stdc++.h>
#include<bitset>
#include<unordered_map>
#define pb push_back
#define bp __builtin_popcount
using namespace std;
typedef  long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e3+100;
const int MOD=1e9+7;
const double PI=3.1415926535;
int lowbit(int x){return x&-x;}
ll gcd(ll x, ll y){ return y == 0 ? x : gcd(y, x%y); }
ll lcm(ll x, ll y){ return x / gcd(x, y)*y; }
inline ll dpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t) % MOD; b >>= 1; t = (t*t) % MOD; }return r; }
inline ll fpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t); b >>= 1; t = (t*t); }return r; }
ll n, m, dp[maxn][maxn];
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        dp[1][i] = 1;
    }
    for (int i = 1; i <= n; i++)
    {
        dp[i][1] = 1;
    }
    for (int i = 2; i <= n;i++)
        for (int j = 2; j <= m;j++)
        {
            if(i%2==0&&j%2==0)continue;
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    cout << dp[n][m] << endl;
    //system("pause");
    return 0;
}

给定一个长度为 n 的数组 A1,A2,⋅⋅⋅,An。

你可以从中选出两个数 Ai 和 Aj(i 不等于 j)，然后将 Ai 和 Aj 一前一后拼成一个新的整数。

例如 12 和 345 可以拼成 12345 或 34512。

注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法，即便是 Ai=Aj 时。

请你计算有多少种拼法满足拼出的整数是 K 的倍数。

输入格式
第一行包含 2 个整数 n 和 K。

第二行包含 n 个整数 A1,A2,⋅⋅⋅,An。

输出格式
一个整数代表答案。

数据范围
1≤n≤105,
1≤K≤105,
1≤Ai≤109
输入样例：
4 2
1 2 3 4
输出样例：
6

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <cstring>
#include <cstdio>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e5+100;
ll cnt[15][maxn];//10的i次方对k取模为j
ll a[maxn],n,k;
ll ans;
void solve()
{
    for(int i=0;i<n;i++)
    {
        ans+=cnt[(int)log10(a[i])+1][(k-a[i]%k)%k];

        for(ll j=1,power=10;j<11;j++)
        {
            cnt[j][a[i]%k*1ll*power%k]++;
            power=power*10%k;
        }
    }
}
int main()
{
    cin>>n>>k;

    for(int i=0;i<n;i++)
    {

        cin>>a[i];
    }
    solve();
    reverse(a,a+n);
    memset(cnt,0,sizeof cnt);
    solve();
    cout<<ans<<endl;

    return 0;


}

思路：每次读入信息的时候就把信息先把权值存到这个节点的祖先头上，等到加进来新的点的时候这时候遍历一遍每个点，把祖先头上的权值加上来，就是先存款，用的时候取出来这个意思，就是这么简单。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e5+100;
int res[maxn],w[maxn],pre[maxn],n,m,op;
int Find(int x) {
  return pre[x] == x ? x : pre[x] = Find(pre[x]);
} 
void unionsearch(int x,int y)
{
    int bx=Find(x);
    int by=Find(y);
    if(bx!=by)
    {
        for(int i=1;i<=n;i++)
        {
            res[i]+=w[Find(i)];
        }
      memset(w,0,sizeof w);
      pre[bx]=by;
    }

}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        pre[i]=i;
    while(m--)
    {
        int x,y;
        scanf("%d%d%d",&op,&x,&y);
        if(op==1)
            unionsearch(x,y);
        else
        {
            w[Find(x)]+=y;
        }
    }
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        cout<<res[i]+w[Find(i)]<<" ";
    }
    cout<<endl;
    //cout<<ans<<endl;

    return 0;

}