【十四届蓝桥杯省赛C++试卷】

答案：A

解析：（C++ 中 bool 类型与 char 类型一样，都需要1 byte。一些其他类型的占用字节数：short：2 byte。int：4 byte。long long：8 byte。double：8 byte。）

答案：C

解析：(A中结构体中可以定义成员变量，也可以定义只有该结构体类型变量可调用的成员函数 B中 所谓结构体的继承特性，指的是在一个已经定义好的旧结构体的基础上，创建一个新结构体，并且新结构体可以复用旧结构体的成员和函数。C正确，D中构造函数可以在创建结构体变量时，按照函数预设的构造规则，将对应成员变量赋值，并执行其他操作。构造函数在创建结构体类型的对象时自动执行，因此无法由用户主动调用，也没有返回值。）

答案：C

解析：以 int a[100]; 为例，最后一个元素为 a[99]，下标索引 99 为数组长度减 1。

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

// 声明常量及变量
const int N = 1e7 + 5;  // N表示可能的质数的上限
int primes[N], p;   // primes数组保存已知的质数列表，p表示质数个数
bool sign[N];       // sign数组用来标记某个数是否是质数
int s[N];           // s数组用来记录每个数的最大质因子个数

// 埃氏筛法初始化质数表
void init_Primes(int n) {
	for (int i = 2; i <= n; i++) {
		if (!sign[i]) primes[p++] = i;      // i是质数，加入质数表中
		for (int j = 0; primes[j] <= n / i; j++) {
			sign[primes[j] * i] = true;     // 将i和质数表中所有不大于n/i的数的积标记为合数
			if (i % primes[j] == 0) break;  // 如果primes[j]是i的因子，则退出循环
		}
	}
}

// 计算数n的最大质因子个数
int tj_(int n) {
	int tj = 0;     // tj表示n的最大质因子个数
	for (int i = 0; i < p; i++) {   // 枚举质数表中所有质数
		while (n % primes[i] == 0) {    // 如果当前质数是n的因子
			tj++;           // 更新最大质因子个数
			n /= primes[i]; // 去掉该质因子
			if (n == 1) return tj;  // 如果n变为了1，则说明所有质因子均被枚举完毕
		}
	}
}

int main() {
	int n, m;
	cin >> n >> m;
	init_Primes(m);     // 初始化质数表
	int res = 0;        // res表示区间内最大质因子个数
	for (int i = n; i <= m; i++) {  // 枚举每个数，计算其最大质因子个数，更新res
		res = max(res, tj_(i));
	}
	cout << res;    // 输出结果
	return 0;
}

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


const int N=1e6+5;
long long n,a[N];

int main() {
	cin>>n;
	for(int i=1; i<=n; i++) cin>>a[i];
	long long ans=0,min_n=0;  // ans 记录最大的面积，min_n 记录当前区间中的最小值
	for(int i=1; i<=n; i++) {
		min_n=N;
		for(int j=i; j<=n; j++) {
			min_n=min(min_n,a[j]);   // 更新当前区间中的最小值
			ans=max(ans,(j-i+1)*min_n);  // 根据更新后的最小值来计算当前区间的面积，并记录最大值
		}
	}
	cout<<ans;  // 输出最大面积
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int N=1e6 +7;
//using LL = long long;
int a[N],b[N],mp[N];
long long  ct[N];
int main() {
	int n;
	scanf("%d",&n);
	for(int i=1; i <= n; ++i) {
		scanf("%d",a + i);
		b[i]= a[i];
	}
//离散化
	sort(b+1,b+n+1);//去重以后，m即为不同的元素个数
	int m =unique(b+1,b+n+1)-b-1;
	for(int i=1; i <= m; ++i) {
		mp[b[i]]= i;
	}

	for(int i = 1; i <= n; ++i) {
		ct[mp[a[i]]]++;
	}

	int l=1,r= m;
	long long tot =0;//每一轮都从最小值开始
	while(l+1<r) {
		if(ct[l]<= ct[r]) {
			//左边删掉ct[1]，右边先删掉ct[1]-1
			tot += ct[l]+ ct[l]-1;
			ct[1+1]+= ct[l];
			ct[r]-= ct[l]-1;
			ct[r-1]+=ct[l]-1;
//判断此时能否结束
			if(++l+1 == r) break;
//对应删除最右边的1个
			tot++,ct[r]--,ct[r-1]++;
//判断右边是否个数为0
			if(!ct[r])--r;
		} else {
			tot += ct[r]+ ct[r];
			ct[l+1]+= ct[r];
			ct[l]-= ct[r];
			ct[r-1]+= ct[r];
			r--;
		}
	}
	printf("%lld %d %d",tot,b[l],b[r]);
}

#include <bits/stdc++.h> // 包含常用的头文件
using namespace std;
const int N=1e5 + 7;
// 记录每个部门及其直接下属参与活动的人数
int f[N][2];
// 存储每个部门的人数
int p[N];
 //边结构体表示树形结构
struct Edge {
    int v; // 目标部门ID
    Edge *nx; // 指向下一个边
    Edge(int _v, Edge *_n):v(_v), nx(_n) {} // 构造函数
}* hd[N];


// 负责存储当前部门下级链表的指针
//Edge* hd[N];

// 深度优先搜索，计算最大参与人数
void dfs(int u, int pa) {
    // 部门u参加活动，则自身人数加上直接下属的参加人数
    f[u][1] += p[u];
    
    // 遍历u的所有下级
    for(Edge *i = hd[u]; i; i = i->nx) {
        int v = i->v; // 当前处理的下级部门
        if (v == pa) continue; // 跳过父级

        // 递归处理下级部门
        dfs(v, u);

        // 更新u的参与人数，包括直接下属和间接下级
        f[u][1] += f[v][0];
        f[u][0] += max(f[v][0], f[v][1]); // 取两者中的较大值
    }
}

// 主函数入口
int main() {
    int n;
    scanf("%d", &n); // 读取部门总数

    // 遍历各部门信息
    for(int i = 1; i <= n; ++i) {
        int u, v, w; // 上级部门、下级部门、人数
        //scanf("%d %d %d", &u, &v, &w);
        cin>>u>>v>>w;
        // 添加边并记录人数
        hd[u] = new Edge(v, hd[u]);
        p[v] = w; // 如果作为上级，它的直接下属人数增加
    }

    // 初始化根节点
    dfs(0, 0);

    // 输出最大参加人数
  // printf("%d\n", f[0][0]);
cout<<f[0][0]; 

}