蓝桥杯 C++项目题库7

3.7***第十二届蓝桥杯青少组省赛 C++中高级
单选题 30.0 分
第一题：下列符号中哪个在 C++中表示行注释（D）。
A. ! B. # C. ] D. //
第二题：每个 C++程序都必须有且仅有一个（C）。
A. 函数 B. 预处理命令 C. 主函数 D. 语句
第三题：下列字特串中不可以用作 C++变量名称的是（B）。
A. str123 B. int C. _6666 D. name
第四题：二进制加法 10010100+110010 的和为（A）。
A. 11000110 B. 10100110 C. 10110110 D. 11100110
第五题：对于 int *pa[5]；的描述中，正确的是（D）。
A. pa 是一个指向数组的指针，所指向的数组是 5 个 int 型元素
B. pa 是一个指向某数组中第 5 个元素的指针，该元素是 int 型变量
C. pa[5]表示数组的第 5 个元素的值，是 int 型的值
D. pa 是一个具有 5 个元素的指针数组，每个元素是一个 int 型指针
3.7.1 整除
输入一个正整数 N（N<100），输出 1 到 N（包含 1 和 N）之间所有可以被 7 整除的
正整数，且输出的正整数之间以一个空格隔开。
输入描述
输入一个正整数 N（N<100）
输出描述
输出可以被 7 整除的正整数，且输出的正整数之间以一个空格隔开
样例输入
15
样例输出
7 14
提示
评分标准：
10 分：能正确输出一组数据：
10 分：能正确输出两组数据；
10 分：能正确输出三组数据。
第 149 页 共 256 页
3.7.2 求和
有一堆砖，需要按照一定规律进行堆放，具体堆放规律如下：
顶层放 1 块砖，第二层放 3 块砖，第三层放 6 块砖，第四层放 10 块砖，依此类推，
每一层砖块的数量为上一层砖块数量加上本层的层数。
例如第五层为 10+5=15。
输入砖块堆放的总层数，按照以上规律，求出砖块的总数。
题目描述：
输入一个正整数 N（3<N<1000）作为砖块堆放的总层数，按照“提示信息”中的堆
放规律，输出砖块的总数。
例如：输入为 3，总层数为 3 层的砖块堆放一共有 1+3+6=10 块砖，则输出 10。
输入描述
输入一个正整数 N（3<N<1000）
输出描述
输出砖块的总数
样例输入
3
样例输出
10
提示
评分标准：
10 分：能正确输出一组数据：
10 分：能正确输出两组数据；
20 分：能正确输出三组数据。
3.7.3 排序
有 N 个瓶子，编号为从 1 到 N，这 N 个瓶子乱序排成一排。现在想对瓶子进行从小
到大排列，要求每次拿出 2 个瓶子进行互换，经过若干次互换后，使得瓶子按编号从
小到大排序，但这样的互换方式有多种，每种互换方式的互换次数也不相同。请你通
过编程计算出最少经过几次互换可以使瓶子按编号从小到大排序。
题目描述：
第一行输入瓶子的个数 N（2<N<100），第二行输入目前瓶子编号的排序情况，输出
第 150 页 共 256 页
最少经过几次互换可以使瓶子按编号从小到大排序。
例如第一行输入的 N 为 5，第二行输入 N 个正整数为 21354，第一次拿出 2 和 1 进行
互换，第二次拿出 5 和 4 进行互换，最少需要两次互换。
输入描述
第一行输入一个正整数 N 表示瓶子的个数（2<N<100）
第二行输入 N 个正整数，之间用一个空格分开，表示瓶子编号目前的排序情况
输出描述
输出最少经过几次互换可以使瓶子按编号从小到大排序
样例输入
5
2 1 3 5 4
样例输出
2
提示
评分标准：
10 分：能正确输出一组数据：
10 分：能正确输出两组数据；
15 分：能正确输出三组数据；
15 分：能正确输出四组数据。
3.7.4 推算
小蓝是一名计算机极客，他在记录一些重要的日子时从不注明年月日，而是用一个整
数替代，比如 4532，后来人们知道，那个整数就是日期，这个整数表示的日期就是他
出生后的第几天。
他出生于：1999-04-30
例如他的日记里记录着获得蓝桥杯国寒总冠军的日子为 7856 这个整数，可以推断出
这一天是 2020-10-31，现在需要请你计算出小蓝日记中其他整数对应的日期。
注意：输出的日期格式：yyyy-mm-dd，如：2020-03-21（月和日小于 10 的需要在月
和日前补 0）
题目描述：
输入一个整数 n（5<n<30000）作为日记中记录的整数，输出这个整数对应的日期（注：
按日期格式输出）。
例如：1999-04-30 为第 1 天，1999-05-01 为第 2 天。
输入描述
第 151 页 共 256 页
输入一个正整数 n（5<n<30000）
输出描述
输出这个整数对应的日期
样例输入
10
样例输出
1999-05-09
#include <iostream>
using namespace std;
bool run_n(int y){
if(y%400==0||(y%4==0&&y%100!=0)) return true;
return false;
}
int mo_d(int y,int m){
if(m==1||m==3||m==5||m==7||m==8||m==10||m==12)
return 31;
else if(m==4||m==6||m==9||m==11) return 30;
else if(m==2)
if(run_n(y)) return 29;
else return 28;
}
int main()
{
int ye=1999,moth=5,day=1;
int n;
cin>>n;
n-=2;
while(1){
int t=mo_d(ye,moth);
if(n>t) {
n-=t;moth++;
if(moth>12) {
moth=1;ye++;
}
}
else {
第 152 页 共 256 页
day+=n;break;
}
}
cout<<ye<<"-"<<moth<<"-"<<day;
return 0;
}
3.7.5 可逆素数
素数：素数就是质数，是一个大于 1 的自然数，且除了 1 和它本身外，不能被其他自
然数整除的数。也就是说，除了 1 和该数本身以外不再有其他的因数的数被称为素数。
最小的素数是 2，1 不是素数。可逆素数：是将一个素数的各个位置的数字顺序倒过
来构成的反序数仍是素数。
例如：2，13，167 顺序或者反序都是素数
题目描述：
输入一个正整故 N（2<=N<10001），输出 2 到 N（包含 2 和 N）之间共有多少个可
逆素数。
例如 2 到 15 之间共有 6 个可逆素数，分别为 2，3，5，7，11.13
输入描述
输入一个正整数 N（2≤N<10001）
输出描述
输出 2 到 N（包含 2 和 N）之间共有多少个可逆素数
样例输入
15
样例输出
6
3.7.6 满二叉树
满二叉树：一棵二叉树，如果每一层的节点数都达到最大值，则这个二叉树就是满二
叉树。即如果一棵二叉树的层数为 K，且结点总数是（2^k）-1，那么它就是满二叉
树。
完全二叉树：一棵深度为 K 的二叉树，除第 K 层外，其他各层（1 至 k-1 层）的节点
数都达到最大值，目第 K 层的所有节点都连续集中在左边，那么它就是完全二叉树。
节点：包含一个数据元素及若干指向子树分支的信息。
权值：对节点赋予的有意义的数量值。
第 153 页 共 256 页
深度：也被称为树的高度，树中所有节点的层次最大值称为树的深度，例如下图中的
二叉树深度都为 4。
编程实现：
给出一棵包含 n 个节点的完全二叉树，节点按照从上到下、从左到右的顺序依次排序，
每个节点上都有一个权值，如下图现在需要将同一深度节点的权值加在一起，然后比
较每个深度的权值之和，输出权值之和最大的深度值。如果有多个深度的权值之和相
同，则输出其中最小的深度（如：深度 2 权值之和为 5，深度 3 权值之和也为 5，则
输出 2）。
注：根的深度为 1
第一行输入完全二叉树节点的总数量 n（5<n<101），第二行输入 n 个正整数作为每
个节点的权值。输出权值之和最大的深度值（如果有多个深度的权值之和相同则输出
其中最小的深度值）。
例如：上图的二叉树，第一行输入为 6，第二行输入为 1 5 6 1 2 3。深度 1 的权值之和
为 1，深度 2 的权值之和为 11，深度 3 的权值之和为 6。其中深度 2 的权值之和最大，
则输出 2。
输入描述
第一行输入一个正整数 n（5<n<101）作为节点的总数量
第二行输入 n 个正整数，且 n 个正整数之间以一个空格隔开
输出描述
输出权值之和最大的深度值
第 154 页 共 256 页
样例输入 1
6
1 5 6 1 2 3
样例输出 1
2
样例输入 2
8
1 5 6 1 2 3 4 100
样例输出 2
4
第 155 页 共 256 页
3.8***第十二届蓝桥杯青少组省赛 c++高级组 6 月
一、选择题
1、表达式 6-1 的值是（A）。
A.整数 5 B.字符 5 C.表达式不合法 D.字符 6
2、若二维数组 a 有 n 列，则在 a[i][j]前元素个数为（B）。
A.i*n+j-1 B.i*n+j C.j*n+i D.i*n+j+1
3、以下叙述中正确的是（C）。
A.break 语句只能用于 switch 语句体中。
B.continue 语句的作用是：使程序的执行流程跳出包含它的所有循环。
C.break 语句只能用在循环体内和 switch 语句体内。
D.在循环体内使用 break 语句和 continue 语句的作用相同。
4、按照“先进后出"原则组织数据的结构是（B）。（30 分）
A.队列 B.栈 C.双向链表 D.二叉树
5、用 0、1、2、3、4 这 5 个数字，能组成多少个没有重复数字的多位偶数？（）
A.144 B.147 C.160 D.163
解题分析：
五位数 24 个
个位是零：4*3*2=24（依次为万位、千位、百位、十位）
四位数 60 个
个位是零：4*3*2=24（依次为千位、百位、十位）
个位不是零：2*3*3*2=36（依次为个位、千位、百位、十位）
三位数 96 个
个位是零：4*3*2
个位不是零：4*4*3*2
两位数 10 个
个位是零：4*1
个位不是零：3*2
3.8.1 字符串倒序输出
给定一个字符串，然后将字符串倒序输出。
输入：输入一个字符串 S(2<strlen(S)<100)
输出：将字符串 S 倒序输出
#include <iostream>
#include <string>
第 156 页 共 256 页
#include <algorithm>
using namespace std;
int main()
{
string s;
getline(cin,s);
reverse(s.begin(),s.end());
cout<<s;
return 0;
}
3.8.2 剪绳子
一条绳子从中间剪一刀可以剪成两段绳子；如果对折 1 次，中间剪一刀可以剪出 3 段
绳子；如果连续对折 2 次，中间剪一刀可以剪出 5 段绳子；那么，连续对折 n 次，中间剪
一刀可以剪出多少段绳子？
通过编写程序，在给定绳子对折次数，计算出中间剪一刀后可剪出绳子的段数。
输入
输入一个正整数口(1 <n< 20)作为绳子对折的次数
输出
输出一个正整数，表示对折 n 次后的绳子中间剪一刀可以剪出绳子的段数
输入样例 3
输出样例 9
#include <iostream>
using namespace std;
int main()
{
int n;
cin>>n;
cout<<(n-1)*2+1<<endl;
return 0;
}
第 157 页 共 256 页
3.8.3 求和
合数指自然数中除了能被 1 和它本身整除外，还能被其他数(0 除外)整除的数。最小
的合数是 4。
如：合数 4 既可以被 1 和 4 整除，还能被 2 整除。
给定一个正整数 N,计算出 4 到 N 之间所有合数的和。
例如：N 等于 7,其中 4 到 N 之间合数有 4、6,所有合数和等于 10 (4+6=10)
输入：输入一个正整数 N(4<N<101)
输出： 输出一个整数，表示 4 到 N 之间(包含 4 和 N)所有合数的和
输入样例 7
输出样例 10
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int n;cin>>n;
int ans=0;
for(int i=4;i<=n;i++){
for(int j=2;j<=i/2;j++)
if(i%j==0) {ans+=i;break;}
}
cout<<ans<<endl;
return 0;
}
3.8.4 求和比较（dp）
小蓝在学习 C++数组时，突发奇想想知道如果将一个连续的正整数数组拆分成两个子
数组，然后对拆分出的两个子数组求和并做差，且差值正好等于一个固定的正整数，像这
样同一连续的正整数数组拆分方案有多少种。
我们一起帮助小蓝设计一下规则∶
第一给出两个正整数 N 和 M;
第二从 1 到 N 组成一个连续正整数数组 A（A={1，2，3，4.…..N}）;
第三将数组 A 拆分成两个子数组 A1、A2 （1.两个子数组中不能出现相同的数;2.子数组
中的数字可以是连续的也可以是不连续的;3.拆分出的两组子数组的元素个数可以不同，
但总数量等于 A 数组元素个数）;
第 158 页 共 256 页
第四对 A1、A2 两个子数组分别求和;
第五对 A1、A2 两个子数组的和做差（大的数字减去小的数字）;
第六如果差值正好等于固定值 M，则判定此拆分方案成立。
如∶N=5，M=1，连续正整数数组 A={1，2，3，4，5}。
符合条件的拆分方案有 3 种∶
A1={1，2，4}，A2={3，5}，其中 A1 的和为 7，A2 的和为 8，和的差值等于 1
A1={1，3，4}，A2={2，5}，其中 A1 的和为 8，A2 的和为 7，和的差值等于 1
A1={3，4}，A2={1，2，5}，其中 A1 的和为 7，A2 的和为 8，和的差值等于 1
输入
分别输入两个正整数 N（3<N<30）和 M（0≤M≤<500）两个正整数由一个空格隔开
输出
输出一个正整数，表示 1 到 N （包含 1 和 N）连续的正整数数组中有多少种方案，使得
拆分的两个子数组部分和的差值等干 M
输出样例 1
输入样例 1 5 1 3
#include <iostream>
#include <cstdio>
using namespace std;
int f[35][35];
int main()
{
int n,m;
cin>>n>>m;
int sum=0;
for(int i=1;i<=n;i++)sum+=i;
sum-=m;
if(sum%2!=0||sum<0){
cout<<0<<endl;return 0;
}
/*设 x 为 A1 的和 设 y 为 A2 的和
则有：x+y=sum y-x=m
则：x=(sum-m)/2 y=x+m
*/
int x=sum/2;
int y=x+m;
/*f[i][j]前 i 个数字和恰好等于 j 的方案数
*/
第 159 页 共 256 页
f[1][1]=1;
for(int i=2;i<=n;i++){
for(int j=1;j<=y;j++){
f[i][j]=f[i-1][j];
if(i==j) f[i][j]++;
if(i<j) f[i][j]+=f[i-1][j-i];
cout<<f[i][j]<<" ";
}
cout<<endl;
}
//m==0 时 有 x、y 互换的重复
if(m==0) cout<<f[n][y]/2<<endl;
else cout<<f[n][y]<<endl;
return 0;
}
3.8.5 最大价值（dp）
一名种菜的农民伯伯，需要在给定的时间内完成种菜，现有 m 种不同的蔬菜提供给
农民伯伯选择，且每种蔬菜种植花费的时间不同，每种蔬菜成熟后售卖的价值也不同。要
求∶
1. 在限定的总时间内进行蔬菜种植，并且种植蔬菜的种类不能超出限制的数量;
2.选择最优的种植方案使得蔬菜成熟后售卖的总价值最大（可选择不同的蔬菜种植）。
例如∶
给定的总时间限制为 55，种植蔬菜的种类限制为 3;
3 种蔬菜，种菜的花费时间及售卖价格分别为∶第一种 21 和 9，第二种 20 和 2，第三种
30 和 21。
最优的种植方案是选择种植第一种和第二种，两种蔬菜种植总时间 30+21。未超过总时间
阳制 55。所种植蔬菜为两种， 也未超讨种类限制的 3 种最大总价值为 9+21=30，这个方
案是最优的。
输入
第一行输入两个正整数 t（1≤t ≤600）和 m（1≤m ≤ 50），用一个空格隔开，t 代表
种菜总时间限制，m 代表最多可种植蔬菜种类的限制接下来的 m 行每行输入两个正整数
t1（1<t1<101）和 p（1<p<101）且用一个空格隔开，t1 表示每种蔬菜种植需要花费的时
间，p 表示对应蔬菜成熟后售卖的价值。
输出
输出一个正整数，表示选择最优的种植方案后，蔬菜成熟后售卖的最大总价值
第 160 页 共 256 页
输入样例 1 30
55 3
21 9
20 2
30 21
输出样例 30
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int t,m;
struct greens{
int tt,p;
}a[605];
int f[55][605];
int main()
{
cin>>t>>m;
for(int i=1;i<=m;i++)
cin>>a[i].tt>>a[i].p;
for(int i=1;i<=m;i++)
for(int j=1;j<=t;j++){
f[i][j]=f[i-1][j];
if(j>=a[i].tt)
f[i][j]=max(f[i][j],f[i-1][j-a[i].tt]+a[i].p);
}
cout<<f[m][t]<<endl;
return 0;
}
3.8.6 精灵王国
在一个矩阵精灵王国里有两个精灵，一个叫黑精灵，个叫白精灵。他们住在一个 N*M
的矩阵方格中的不同位置，黑精灵住在矩阵方格的左上角方格里（1，1），白精灵住在矩
阵方格的右下角方格里（N，M）。
在这个矩阵方格单还有一对可穿越的门，这对穿越门的位置不固定，位置可变换 （穿越
第 161 页 共 256 页
门不会出现在矩阵方格左上角和右下角位置，也不会重善出现，有且只有一对）。穿越门
的功能是当进入其中一扇门的位置后可直接穿越到另一扇门的位置。
如下图所示∶
一天黑精灵要去白精灵家做客，需要穿过方格矩阵到达白精灵家，穿行矩阵方格要求∶
1.每次只能走一个方格，可以向上、向下、向左、向右行走;
2.每走一个方格计为 1 步，但从一扇穿越门穿越到另一扇穿越门不记步数（从方格走到穿
越门和从穿越门到其他方格都计 1 步）;
3.可借助穿越门去白精灵家（可减少行走步数）。
为了尽快到达白精灵家，请你帮助黑精灵找一条最短路线，并且计算出最短路线的步数。
例如∶
给出一个 3*4 矩阵方格，并给出第一个穿越门的标位置 N1. M1（2.3） ，第二个穿越门
的坐标位置 N2，M2（3.1）已知黑精灵初始坐标位置左上角（1，1），白精灵坐标位置
右下角（N，M）。
假设用两个大写字母"D"表示矩阵方格中穿越门位置，1 代表黑精灵，2 代表白精灵，用
数字 0 表示剩余矩阵方格。
如下图所示∶
按照穿行矩阵方格要求为左上角方格的黑精灵到右下角方格白精灵家找一条最短路线，计
算出最短路线的步数。
路线∶从黑精灵初始位置（1，1）到正下方方格（2，1）走 1 步，正下方方格（2，1）到
其下方穿越门（3，1）"D"走 1 步，然后穿越到另一扇穿越门（2，3）向正下方（3，3）
走 1 步，最后到达白精灵家（3，4）需要走 1 步，故最短路线需要 4 步。
输入
第一行输入两个以一个空格隔开的正整数 N（2<N<101），M（2<M<101），分别表示 N
行 M 列的方格矩阵;
接下来第二行输入两个以一个空格隔开的正整数∶N1（N1≤N），M1（M1≤M），代表
第一个穿越门位于第 N1 行第 M1 列;接下来第三行输入两个以一个空格隔开的正整数∶
N2（N2≤N），M2（M2≤M），代表第二个穿越门位于第 N2 行第 M2 列;
注意∶两个穿越门位置不能重叠，即不能同时满足 N1=N2 和 M1=M2;两个穿越门位置也
不能位于左上角（1，1）和右下角（M，N）;第一个穿越门位置要在第二个穿越门前边或
者上边。
输出
输出一个整数，表示黑精灵去白精灵家最短路线需要走多少步（可借助穿越门，减少步数），
如果没有能到达白精灵家的路线或者其他情况统一输出数字"0"。
输出样例 1
输入样例 1 4
3 4 2 3 3 1
#include<cstdio>
第 162 页 共 256 页
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
int n,m,n1,m1,n2,m2;
cin>>n>>m>>n1>>m1>>n2>>m2;
int s1=(n-1)+(m-1);
int s2=(n1-1)+(m1-1)+(n-n2)+(m-m2);
int s3=(n2-1)+(m2-1)+(n-n1)+(m-m1);
int s=min(s1,min(s2,s3));
cout<<s<<endl;
return 0;
}
3.9***第十二届蓝桥省赛 C++大学生组 青少组省赛参考
3.9.1 空间
小蓝准备用 256MB 的内存空间开一个数组，数组的每个元素都是 32 位
二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问
256MB 的空间可以存储多少个 32 位二进制整数？
256MB 换算成 B 就是 256*1024*1024
转换成位有 256*1024*1024*8
32 位整数就是 256*1024*1024*8/32
3.9.2 卡片
小蓝有很多数字卡片，每张卡片上都是数字 0 到 9。
小蓝准备用这些卡片来拼一些数，他想从 1 开始拼出正整数，每拼一个，
就保存起来，卡片就不能用来拼其它数了。
小蓝想知道自己能从 1 拼到多少。
例如，当小蓝有 30 张卡片，其中 0 到 9 各 3 张，则小蓝可以拼出 1 到 10，
但是拼 11 时卡片 1 已经只有一张了，不够拼出 11。
第 163 页 共 256 页
现在小蓝手里有 0 到 9 的卡片各 2021 张，共 20210 张，请问小蓝可以从 1
拼到多少？
提示：建议使用计算机编程解决问题。
开个数组存下 0-9 卡牌的数量，
然后从 1 开始往后遍历
每次都分解当前遍历的数
如果出现卡牌数量为零
说明当前数无法拼出
直接输出上一个数
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[11];
int main(){
for(int i=0;i<10;i++)
a[i]=2021;
int cnt=1;
while(1){
int x=cnt;
while(x){
if(a[x%10]==0){
cout<<cnt-1<<endl;
return 0;
}
a[x%10]--;
x/=10;
}
cnt++;
}
}
//3181
3.9.3 货物摆放
小蓝有一个超大的仓库，可以摆放很多货物。现在，小蓝有 n 箱货物要摆放在仓库，每
第 164 页 共 256 页
箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都
必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的立方体。即在长、宽、高的方向上
分别堆 L、W、H 的货物，满足 n = L × W × H。
给定 n，请问有多少种堆放货物的方案满足要求。
例如，当 n = 4 时，有以下 6 种方案：1×1×4、1×2×2、1×4×1、2×1×2、 2 × 2
× 1、4 × 1 × 1。
请问，当 n = 2021041820210418 （注意有 16 位数字）时，总共有多少种
方案？
先质因数分解得到
2 1
3 3
17 1
131 1
2857 1
5882353 1
对于 2、17、131、2857、5882353，有 3^5=243 种方案
对于 3， 3、3、3 时有 1 种，1、3、9 有 6 种，1、1、27 有 3 种，合计 10 种
所以总方案数就是 243*10=2430
#include<bits/stdc++.h>
#define ll long long
using namespace std;
vector<int> prime;
int num[10000005];
bool vis[10000005];
void shai(){
memset(vis,0,sizeof(vis));
for(int i=2;i<=10000000;i++){
if(!vis[i]){
prime.push_back(i);
for(int j=i+i;j<=10000000;j+=i){
vis[j]=1;
}
}
}
return;
}
第 165 页 共 256 页
vector<int> v;
int main(){
shai();
ll n=2021041820210418;
for(int i=0;i<prime.size();i++){
num[i]=0;
while(n%prime[i]==0){
n/=prime[i];
num[i]++;
}
if(num[i]!=0)
v.push_back(i);
}
//ll check=1;
for(int i=0;i<v.size();i++){
cout<<prime[v[i]]<<' '<<num[v[i]]<<endl;
//for(int j=1;j<=num[v[i]];j++)
//check*=prime[v[i]];
}
//cout<<check<<endl;
}
//2430
3.9.4 时间显示
小蓝要和朋友合作开发一个时间显示的网站。在服务器上，朋友已经获取了当前的时间，
用一个整数表示，值为从 1970 年 1 月 1 日 00:00:00 到当前时刻经过的毫秒数。
现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要显示出时分秒即
可，毫秒也不用显示，直接舍去即可。
给定一个用整数表示的时间，请将这个时间对应的时分秒输出。
【输入格式】
输入一行包含一个整数，表示时间。
【输出格式】
输出时分秒表示的当前时间，格式形如 HH:MM:SS，其中 HH 表示时，值
为 0 到 23，MM 表示分，值为 0 到 59，SS 表示秒，值为 0 到 59。时、分、秒
不足两位时补前导 0。
第 166 页 共 256 页
【样例输入 1】
46800999
【样例输出 1】
13:00:00
【样例输入 2】
1618708103123
【样例输出 2】
01:08:23
【评测用例规模与约定】
对于所有评测用例，给定的时间为不超过 1018 的正整数。
一天的时间是 86400000ms
将输入的数据对 86400000 取模，
然后再除以 1000 就是从当天 00:00:00 到现在经过的秒数。
每 3600 秒是一个小时，然后剩余的时间每 60 秒是一分钟，最后剩余的就是秒。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll a;
cin>>a;
a%=86400000;
a/=1000;
int h=a/3600,m=(a%3600)/60,s=a%60;
if(h>=10)
cout<<h<<':';
else
cout<<'0'<<h<<':';
if(m>=10)
cout<<m<<':';
else
cout<<'0'<<m<<':';
if(s>=10)
cout<<s;
else
cout<<'0'<<s;
}
第 167 页 共 256 页
3.9.5 砝码称重
你有一架天平和 N 个砝码，这 N 个砝码重量依次是 W1, W2, · · · , WN。
请你计算一共可以称出多少种不同的重量？
注意砝码可以放在天平两边。
【输入格式】
输入的第一行包含一个整数 N。
第二行包含 N 个整数：W1, W2, W3, · · · , WN。
【输出格式】
输出一个整数代表答案。
【样例输入】
3
1 4 6
【样例输出】
10
【样例说明】
能称出的 10 种重量是：1、2、3、4、5、6、7、9、10、11。
1 = 1；
2 = 6 ? 4 (天平一边放 6，另一边放 4)；
3 = 4 ? 1；
4 = 4；
5 = 6 ? 1；
6 = 6；
7 = 1 + 6；
9 = 4 + 6 ? 1；
10 = 4 + 6；
11 = 1 + 4 + 6。
【评测用例规模与约定】
对于 50% 的评测用例，1 ≤ N ≤ 15。
对于所有评测用例，1 ≤ N ≤ 100，N 个砝码总重不超过 100000。
跑两遍 01 背包，
第一遍是加砝码，第二遍是减砝码。
（对于减砝码
如果已经加上了当前的砝码，则相当于把砝码拿下来
如果没有加当前的砝码，则相当于把砝码放在天平另一边
因此不会冲突）
#include<bits/stdc++.h>
第 168 页 共 256 页
#define ll long long
using namespace std;
int dp[100005];
int w[105];
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>w[i];
}
memset(dp,0,sizeof(dp));
dp[0]=1;
for(int i=1;i<=n;i++){
for(int j=100000;j>=w[i];j--){
dp[j]=max(dp[j],dp[j-w[i]]);
}
}
for(int i=1;i<=n;i++){
int siz=100000-w[i];
for(int j=1;j<=siz;j++){
dp[j]=max(dp[j],dp[j+w[i]]);
}
}
int ans=0;
for(int i=1;i<=100000;i++){
ans+=dp[i];
}
cout<<ans<<endl;
}
第 169 页 共 256 页
3.9.6 杨辉三角形
下面的图形是著名的杨辉三角形：
如果我们按从上到下、从左到右的顺序把所有数排成一列，可以得到如下
数列：
1, 1, 1, 1, 2, 1, 1, 3, 3, 1, 1, 4, 6, 4, 1, …
给定一个正整数 N，请你输出数列中第一次出现 N 是在第几个数？
【输入格式】
输入一个整数 N。
【输出格式】
输出一个整数代表答案。
【样例输入】
6
【样例输出】
13
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ N ≤ 10；
对于所有评测用例，1 ≤ N ≤ 1000000000。
二项式定理，对于 C(3，n)，当 n 等于 2000 时，C(3，2000)＞1e9
因此只需要算到第 2000 行就好了，剩下的再算 C(1，n)和 C(2，n)就好了。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[2005][2005];
int main(){
ll N;
cin>>N;
memset(a,0,sizeof(a));
a[0][0]=1;
for(int i=1;i<2005;i++){
第 170 页 共 256 页
for(int j=1;j<=i;j++){
a[i][j]=a[i-1][j]+a[i-1][j-1];
if(a[i][j]==N){
cout<<i*(i-1)/2+j<<endl;
return 0;
}
}
}
//如果上面的没找到，说明只有 C(1,n)和 C(2,n)满足了
//n*(n-1)/2==N
ll n=sqrt(N*2)+1;
if(n*(n-1)/2==N){
//C(2,n)
cout<<n*(n+1)/2+3<<endl;
}else{
//C(1,n)
cout<<N*(N+1)/2+2<<endl;
}
}
3.9.7 双向排序
给定序列 (a1, a2, · · · , an) = (1, 2, · · · , n)，即 ai = i。
小蓝将对这个序列进行 m 次操作，每次可能是将 a1, a2, · · · , aqi 降序排列，
或者将 aqi , aqi+1, · · · , an 升序排列。
请求出操作完成后的序列。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示序列的长度和操作次数。
接下来 m 行描述对序列的操作，其中第 i 行包含两个整数 pi, qi 表示操作
类型和参数。当 pi = 0 时，表示将 a1, a2, · · · , aqi 降序排列；当 pi = 1 时，
表示
将 aqi , aqi+1, · · · , an 升序排列。
【输出格式】
输出一行，包含 n 个整数，相邻的整数之间使用一个空格分隔，表示操作
完成后的序列。
【样例输入】
3 3
第 171 页 共 256 页
0 3
1 2
0 2
【样例输出】
3 1 2
【样例说明】
原数列为 (1, 2, 3)。 第 1 步后为 (3, 2, 1)。 第 2 步后为 (3, 1, 2)。 第 3 步后
为 (3, 1, 2)。与第 2 步操作后相同，因为前两个数已经是降序了。
【评测用例规模与约定】
对于 30% 的评测用例，n, m ≤ 1000；
对于 60% 的评测用例，n, m ≤ 5000；
对于所有评测用例，1 ≤ n, m ≤ 100000，0 ≤ ai ≤ 1，1 ≤ bi ≤ n。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
/*
int main(){
}
*/
//暴力分 n*n*logn
bool cmp(int x,int y){
return x>y;
}
int a[100005];
int main(){
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)
a[i]=i;
while(m--){//1e5
int p,q;
cin>>p>>q;
//nlogn
if(p==0){
sort(a+1,a+q+1,cmp);
第 172 页 共 256 页
}else{
sort(a+q,a+n+1);
}
for(int i=1;i<=n;i++)
cout<<a[i]<<' ';
cout<<endl;
}
for(int i=1;i<=n;i++)
cout<<a[i]<<' ';
}
3.9.8 趣数（动态规划题目 省赛难度）
如 126543 这样的数，6 是其中最大的，在 6 的左边越来越大，在 6 的右边越来越小，并
且在这个数中，1、2、3、4、5、6 各出现一次，我们把这样的数叫 6 的趣数。
编程实现
输入数字 N（3<=N<=9)
输出 N 的趣数，数字间用空格分开。
输入样例
4
输出样例
1243 1342 1432 2341 2431 3421
#include <iostream>
using namespace std;
int a[10],book[10],n;
bool judge(){
int i=1;
if(a[i]==n||a[n]==n) return false;
while(a[i]<n&&a[i]<a[i+1])i++;
i++;
while(a[i]<n&&a[i]<a[i-1]&&i<=n)i++;
i--;
if(i==n) return true;
else return false;
}
void dfs(int step)
{
int i;
while(step==n+1){
if(judge()){
for(int i=1;i<=n;i++)
cout<<a[i];
cout<<" ";
}
return ;
}
for(i=1;i<=n;i++){
if(book[i]==0){
a[step]=i;
book[i]=1;
dfs(step+1);
book[i]=0;
}
}
}
int main(int argc, char *argv[]){
cin>>n;
dfs(1);
return 0;
}
3.9.9 括号合法组合
循环以及循环的嵌套，是同学们编写程序时常见的操作。如果用一对括号来代表一个循环
的话，那么三个循环出现的合法组合有 5 种，分别为：“{}{}{} ”、“{{{}}}”、“{{}{}}”、
“{{}}{}”、“{}{{}}”。
第 174 页 共 256 页
输入：一个数字 n（1<=n<=10），代表循环的个数。
输出：输出 n 个循环的合法组及组合个数。
样例输入 1：
2
样例输出 1：
{}{}
{{}}
2
样例输入 2：
3
样例输出 2：
{}{}{}
{{}}{}
{}{{}}
{{}{}}
{{{}}}
5
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int n,lf,rt,s,tj,tmp;
int aa[65];
int main( )
{
cin>>n;
int t=1,a=0,b=0;
tj=0;
for(int i=1;i<=2*n;i++){
if(i%2==0)a+=t;
if(i>n)b+=t;
t*=2;
}
// cout<<a<<" "<<b<<endl;
for(int j=a;j<=b;j++){
t=j;
lf=rt=0;s=1;
第 175 页 共 256 页
memset(aa,0,sizeof(aa));
while(t>0){
if(t&1){lf++;aa[s]=1;}
else {rt++;aa[s]=0;}
if(lf>rt)break;
s++;
t=t>>1;
}
if(aa[1]==0&&lf==rt&&lf==n){
tj++;
for(int i=1;i<s;i++){
if(aa[i]==0) cout<<"{";
else cout<<"}";
}
cout<<"\n"; //cout<<endl;
}
}
cout<<tj<<endl; //printf("%d\n",tj);
return 0;
}