2021蓝桥杯C/C++B组真题

1.空间

小蓝准备用256MB的内存空间开一个数组，数组的每个元素都是32 位二进制整数。如果不考虑程序占用的空间和维护内存需要的辅助空间，请问256MB 的空间可以存储多少个32 位二进制整数？

256x1024x1024x8/32=67108864

2.卡片

小蓝有很多数字卡片，每张卡片上都是数字0到9。
小蓝准备用这些卡片来拼一些数，他想从1开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其它数了。
小蓝想知道自己能从1 拼到多少。
例如，当小蓝有30 张卡片，其中0到9 各3 张，则小蓝可以拼出1到10，但是拼11 时卡片1已经只有一张了，不够拼出11。
现在小蓝手里有0 到9 的卡片各2021 张，共20210 张，请问小蓝可以从1拼到多少？
提示：建议使用计算机编程解决问题。

方法一：输出1到一个数，粘贴到word里，查找每个数字的个数进行增加或减少
方法二：

#include
using namespace std;

int main(){
	int cnt[10];
	for(int i = 0;i <= 9;++i)
	cnt[i] = 2021;
	
	int p=1;
	while(true){
		int x=p;
		
		while(x){
			if(cnt[x%10]==0){
				cout<<p-1<<endl;
				return 0;
			}
			cnt[x%10]-=1;
			x=x/10;
		}
		
		p=p+1;
	}
	
	return 0;
}

3.直线

在平面直角坐标系中，两点可以确定一条直线。
如果有多点在一条直线上，那么这些点中任意两点确定的直线是同一条。
给定平面上2 × 3 个整点{(x, y)|0 ≤ x < 2, 0 ≤ y < 3, x ∈ Z, y ∈ Z}，
即横坐标是0 到1 (包含0 和1) 之间的整数、纵坐标是0 到2 (包含0 和2) 之间的整数的点。
这些点一共确定了11 条不同的直线。
给定平面上20 × 21 个整点{(x, y)|0 ≤ x < 20, 0 ≤ y < 21, x ∈ Z, y ∈ Z}，
即横坐标是0 到19 (包含0 和19) 之间的整数、纵坐标是0 到20 (包含0 和20) 之间的整数的点。
请问这些点一共确定了多少条不同的直线。

40257

gcd约分
int gcd(int a,int b){
	if(b == 0) return a;
	return gcd(b, a % b);
}

4.货物摆放

小蓝有一个超大的仓库，可以摆放很多货物。
现在，小蓝有n 箱货物要摆放在仓库，每箱货物都是规则的正方体。
小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的立方体。即在长、宽、高的方向上分别堆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 位数字）时，总共有多少种
方案？
提示：建议使用计算机编程解决问题。

#include
#include
using namespace std;
typedef unsigned long long ll;  //使用typedef为现有类型创建别名，定义易于记忆的类型名 
ll n = 2021041820210418;
ll a[3000], cnt = 0; //存放因子
int main(void)
{
  //找出所有因子放进数组
  for(int i = 1; i <= sqrt(n); i++){
    if(n % i == 0){
      a[++cnt] = i;
      if(i*i != n) 
      a[++cnt] = n/i;
    }
  }
  //循环
  ll res = 0;
  for(int l = 1; l <= cnt; l++)
  for(int w = 1; w <= cnt; w++)
  for(int h = 1; h <= cnt; h++)
    if(a[l]*a[w]*a[h] == n) res++;
 
  cout <<res;
  return 0;
}

2430

5.路径

小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图中的最短路径。
小蓝的图由2021 个结点组成，依次编号1 至2021。
对于两个不同的结点a, b，如果a 和b 的差的绝对值大于21，则两个结点之间没有边相连；
如果a 和b 的差的绝对值小于等于21，则两个点之间有一条长度为a 和b 的最小公倍数的无向边相连。
例如：结点1 和结点23 之间没有边相连；结点3 和结点24 之间有一条无向边，长度为24；
结点15 和结点25 之间有一条无向边，长度为75。
请计算，结点1 和结点2021 之间的最短路径长度是多少。
提示：建议使用计算机编程解决问题。

Floyd算法
多源算法，一次性计算出所有点之间相互的最短距离。
​算法思路，来自于动态规划，故其核心为该表达式：
m a p [ i ] [ j ] = min ⁡ ( m a p [ i ] [ j ] , m a p [ i ] [ k ] + m a p [ k ] [ j ] ）

    void Floyd()
    {
        for (int k = 0; k < num; k++)
        {
            for (int i = 0; i < num; i++)
            {
                for (int j = 0; j < num; j++)
                {
                    if (map[i][j] > map[i][k] + map[k][j])
                    {
                        map[i][j] = map[i][k] + map[k][j];
                    }
                }
            }
        }
    }

最小公倍数：a*b/gcd(a,b)

#include
using namespace std;

typedef long long ll;
const int N = 2030;
const int inf = 1e9 + 7; //无穷大 

int g[N][N];

int gcd(int a,int b){
	return b == 0 ? a:gcd(b,a%b);
}

int main(){
	for(int i=1;i<=2021;++i){
		for (int j=1;j<=2021;++j){
			g[i][j] = inf;         //初始化图 
		}
	}
	
	for (int i=1;i<=2021;++i){
		for (int j=1;j<=2021;++j){
			if(abs(i-j)<=21)
			g[i][j]=i*j/gcd(i,j);
		}
	}
	for(int k=1;k<=2021;++k){
	  for(int i=1;i<=2021;++i){
	   for(int j=1;j<=2021;++j){
	   	g[i][j]=min(g[i][j],g[i][k] + g[k][j]);
	   }
   }
}
cout<<g[1][2021];
return 0;
}

10266837

6.时间显示

小蓝要和朋友合作开发一个时间显示的网站。在服务器上，朋友已经获取了当前的时间，用一个整数表示，值为从 1970 年 1 月 1 日 00:00:00 到当前时刻经过的毫秒数。现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要显示出时分秒即可，毫秒也不用显示，直接舍去即可。给定一个用整数表示的时间，请将这个时间对应的时分秒输出。
【输入格式】
输入一行包含一个整数，表示时间。
【输出格式】
输出时分秒表示的当前时间，格式形如 HH:MM:SS，其中 HH 表示时，值为 0 到 23，MM 表示分，值为 0 到 59，SS 表示秒，值为 0 到 59。时、分、秒。不足两位时补前导 0。
【样例输入 1】
46800999
【样例输出 1】
13:00:00
【样例输入 2】
1618708103123
【样例输出 2】
01:08:23

#include
#include
using namespace std;
typedef long long LL;

int main()
{
    LL n;
    cin>>n;
    n/=1000;
    int h=n/3600%24;
    n=n%3600;
    int m=n/60%60;
    n=n%60;
    int s=n%60;
    printf("%02d:%02d:%02d",h,m,s);
    return 0;
}

#include
#include
using namespace std;
typedef long long ll;
int main(){
    ll cnt;
    cin>>cnt;
    cnt/=1000;
    cnt%=86400;
    printf("%02d:%02d:%02d",cnt/3600,cnt/60%60,cnt%60);
	return 0;
}

7.砝码称重

你有一架天平和 N 个砝码，这 N 个砝码重量依次是 W1,W2,⋅⋅⋅,WN。请你计算一共可以称出多少种不同的正整数重量？注意砝码可以放在天平两边。
输入格式
输入的第一行包含一个整数 N。
第二行包含 N 个整数：W1,W2,W3,⋅⋅⋅,WN。
输出格式
输出一个整数代表答案。
数据范围
对于 50% 的评测用例，1≤N≤15。
对于所有评测用例，1≤N≤100，N 个砝码总重不超过 100000。
输入样例：
3
1 4 6
输出样例：
10

从1-n遍历，对于每一个i，前i个砝码进行加加减减可以生成k个重量，然后用这k个重量与当前的第i个重量进行加加减减。遍历完后，统计生成的重量即可。dp

#include
using namespace std;
typedef long long ll;
int dp[102][100005];//前i个砝码可以称出质量j 
int w[102];
int n;
int sum = 0;
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
		sum += w[i];
	}
	dp[0][0] = 1;//前0件 可以称出重量为0
	for (int i = 1; i <= n; i++) {   //有n*sum个状态
		for (int j = 0; j <= sum; j++) {//这里j不能从1开始 必须从0 第一件物品不可能称出0 但是前i件可能称出0
			dp[i][j] = dp[i - 1][abs(j - w[i])] + dp[i - 1][j + w[i]] +dp[i - 1][j];
		}
	}
	int ans = 0;
	for (int i = 1; i <= sum; i++) {
		if (dp[n][i] != 0) {
			ans++;
		}
	}
	cout << ans;
	return 0;
}

#include
#include
#include
using namespace std;
const int N = 110, M = 2e5 + 10;
int n,m;//m记录最大重量
int a[N];
bool dp[N][M];//dp[i][j]表示前i个砝码，称出j的集合，值为bool值，能称出j就true
//砝码称重
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i],m+=a[i];
    dp[0][0]=true;
    
    for (int i = 1; i <= n;i++)//前i个
        for (int j = 0; j <=m;j++)//称出j
            dp[i][j]=dp[i-1][j]||dp[i-1][j+a[i]]||dp[i-1][abs(j-a[i])];
            //只要有一种情况为真，那么dp[i][j]就真
    int ans=0;
    for(int i=1;i<=m;i++)
        if(dp[n][i])
            ans++;
    cout<<ans;
    return 0;
}

8.杨辉三角

// 二项式定理，对于C(3，n)，当n等于2000时，C(3，2000)＞1e9
// 因此只需要算到第2000行就好了，剩下的再算C(1，n)和C(2，n)就好了。

#include
#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++){
		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;
	}
}