GESP2025年3月认证C++八级( 第一部分选择题（11-15））

杨辉三角形：

#include <iostream>
using namespace std;

#define N 35  // 最多支持输出 35 行
int a[N];    // 一维数组，用于存储当前行的杨辉三角数

int main() {
    int n;
    cin >> n;  // 输入要输出的行数

    for (int i = 0; i < n; i++) {
        a[i] = 1;  // 每一行末尾的元素是 1

        // 关键：从后往前更新，避免覆盖原始数据
        for (int j = i - 1; j > 0; j--)
            a[j] += a[j - 1];  // 杨辉三角递推公式：a[j] = a[j] + a[j - 1]

        // 输出当前行的所有元素
        for (int j = 0; j <= i; j++)
            cout << a[j] << " ";

        cout << endl;  // 换行
    }

    return 0;
}

Floyd算法：

#include <iostream>
using namespace std;

#define N 21            // 最多支持 20 个点（编号从 1 到 20）
#define INF 99999999    // 设定一个“无穷大”表示不可达路径

int map[N][N];          // 邻接矩阵：存储各点间的最短距离

int main() {
    int n, m;           // n：点的个数，m：边的个数
    int t1, t2, t3;     // 每条边的起点、终点、权重（距离）

    cin >> n >> m;

    // 初始化邻接矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j)
                map[i][j] = 0;        // 自己到自己距离为 0
            else
                map[i][j] = INF;      // 其他点先设为不可达（无穷大）
        }
    }

    // 读入图的边信息
    for (int i = 1; i <= m; i++) {
        cin >> t1 >> t2 >> t3;
        map[t1][t2] = t3;             // 有向图：从 t1 到 t2 的边权为 t3
    }

    // Floyd 算法核心部分：三重循环尝试所有中转点
    for (int k = 1; k <= n; k++) {          // 枚举中转点 k
        for (int i = 1; i <= n; i++) {      // 枚举起点 i
            for (int j = 1; j <= n; j++) {  // 枚举终点 j
                if (map[i][j] > map[i][k] + map[k][j]) {
                    map[i][j] = map[i][k] + map[k][j];  // 发现更短路径就更新
                }
            }
        }
    }

    // 输出最终的最短路径表
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cout.width(4);                  // 设置输出宽度对齐
            cout << map[i][j];              // 输出 i 到 j 的最短距离
        }
        cout << endl;
    }

    return 0;
}

欧拉筛法：

#include <iostream>
using namespace std;

const int MAXN = 10000; // 筛选范围：2 ~ MAXN
const int MAXP = 1229;  // 小于等于 10000 的质数最多 1229 个

int primes[MAXP];       // 存储所有筛出来的质数
int num = 0;            // 质数数量统计
bool isPrime[MAXN + 1] = {false}; // false 表示“是质数”，true 表示“不是质数”

void sieve() {
    for (int n = 2; n <= MAXN; n++) {
        if (!isPrime[n]) {
            primes[num++] = n; // 当前是质数，记录下来
        }

        // 用当前质数列表来筛掉 n 的倍数
        for (int i = 0; i < num && n * primes[i] <= MAXN; i++) {
            isPrime[n * primes[i]] = true; // n * primes[i] 一定是合数

            // 如果 primes[i] 是 n 的最小质因子，则 break，避免重复标记
            if (n % primes[i] == 0)
                break;
        }
    }
}