C++ 基础实战：从循环控制到算法入门

函数与模块化编程

将功能封装成函数有助于代码复用和维护。主函数内的变量作用域有限，全局变量则需注意命名冲突。

#include <iostream>
using namespace std;

long long a[55];

long long fbnq(int n) {
    a[1] = 1, a[2] = 1;
    for (int i = 3; i <= n; i++) {
        a[i] = a[i - 1] + a[i - 2];
    }
    return a[n];
}

int main() {
    int n;
    cin >> n;
    cout << fbnq(n) << endl;
    return 0;
}

函数类型说明

注意：void 函数中若有 return，必须不带参数，否则编译报错。

多重循环

嵌套循环常用于处理二维数据或组合问题。使用时需警惕时间复杂度，三重循环在大数据量下容易超时。

for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        for (int k = 0; k < 100; k++) {
            // 核心逻辑
        }
    }
}

练习：饲料调配

给定三种饲料的营养成分及需求，求满足条件的最小用量组合。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long LL;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    int a1, b1, c1;
    cin >> a1 >> b1 >> c1;
    int a2, b2, c2;
    cin >> a2 >> b2 >> c2;
    int a3, b3, c3;
    cin >> a3 >> b3 >> c3;

    for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 100; j++) {
            for (int k = 0; k < 100; k++) {
                if (!i && !j && !k) continue;
                int x = a1 * i + a2 * j + a3 * k;
                int y = b1 * i + b2 * j + b3 * k;
                int z = c1 * i + c2 * j + c3 * k;
                if (x * b == y * a && y * c == b * z && x % a == 0) {
                    cout << i << " " << j << " " << k << " " << x / a << endl;
                    return 0;
                }
            }
        }
    }
    cout << "NONE" << endl;
    return 0;
}

while 循环

while 循环本质是基于条件判断的重复执行。当循环次数不确定时使用。

while (true) {
    // 条件成立继续，不成立退出
    // 注意确保有 break 机制防止死循环
}

练习：数根计算

将一个数的各位数字相加，若结果仍为多位数则继续相加，直到得到一位数。

结构体

C++ 结构体默认访问权限为 public，适合存储相关数据集合。

定义与初始化

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    float score;
};

int main() {
    Student stu1;
    stu1.name = "张三";
    stu1.age = 20;
    stu1.score = 85.5;
    cout << "姓名：" << stu1.name << endl;
    return 0;
}

支持聚合初始化、指定成员初始化及构造函数。

嵌套与数组

结构体可嵌套使用，也可作为数组元素管理批量数据。

struct Address {
    string city;
    string street;
    int number;
};

struct Student {
    string name;
    Address addr;
};

Student class1[3] = {
    {"张三", {"北京", "长安街", 1}},
    {"李四", {"上海", "南京路", 2}},
    {"王五", {"广州", "天河路", 3}}
};

运算符重载

通过重载运算符，可以使结构体行为更接近内置类型。

struct Vector2 {
    float x, y;
    Vector2 operator+(const Vector2& other) const {
        return Vector2(x + other.x, y + other.y);
    }
};

ASCII 码与字符串

字符在内存中以 ASCII 码形式存储。char 类型可隐式转换为 int 获取编码值。

char s = 'A';
int a = s; // a 的值为 65

C++ 的 string 类支持类似数组的下标访问，但不支持负索引。

练习：史莱姆融合

相邻相同颜色的史莱姆会融合，求最终数量。

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    int count = 1;
    for (int i = 1; i < n; i++) {
        if (s[i] != s[i - 1]) {
            count++;
        }
    }
    cout << count << endl;
    return 0;
}

递归与回溯

递归指函数调用自身的过程。关键在于设置终止条件，避免死循环。

欧几里得算法

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

回溯法

回溯是一种试错算法，常用于全排列、组合等问题。核心思想是尝试当前路径，若不可行则回退并尝试下一条。

bool vis[10];
int plan[10];
int n;

void dfs(int step) {
    if (step == n + 1) {
        for (int i = 1; i <= n; i++) cout << plan[i] << " ";
        cout << endl;
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (vis[i]) continue;
        plan[step] = i;
        vis[i] = 1;
        dfs(step + 1);
        vis[i] = 0; // 回溯
    }
}

高精度算法

当数值超过 long long 范围时，需用数组模拟竖式运算。

加法实现

采用逆序存储（个位在索引 1），方便处理进位。

void addBIG(int a[], int b[], int c[]) {
    c[0] = max(a[0], b[0]);
    int u = 0;
    for (int i = 1; i <= c[0]; i++) {
        int t = a[i] + b[i] + u;
        c[i] = t % 10;
        u = t / 10;
    }
    if (u > 0) c[++c[0]] = u;
}

减法逻辑类似，需注意借位处理。完整的高精度实现涉及更多细节，建议结合具体题目实践。