#include<bits/stdc++.h> 是一个在 C++ 编程中经常使用的头文件，它包含了 C++ 标准库中几乎所有的头文件。因此，它在很多竞赛编程或者快速原型开发中被广泛使用，因为它可以避免手动包含每一个单独需要的库文件。
不过，需要注意以下几点：
#include<bits/stdc++.h> 这个文件并不是 C++ 标准的一部分，它是 GCC（GNU Compiler Collection）编译器的一部分，因此它可能在其他编译器上不可用。例如，Visual Studio 编译器就不支持这个头文件。所以，#include<bits/stdc++.h> 虽然非常方便，尤其是在竞赛编程中，但并不是一个“万能库”，也不是推荐在所有情况下使用的库。
在 C 语言中，动态数组指的是在程序运行时动态分配的数组，其大小不需要在编译时确定。我们通过动态内存分配函数（如 malloc、calloc 和 realloc）来实现动态数组。
malloc 分配动态数组：malloc 函数可以分配指定大小的内存。它返回一个 void* 类型的指针，需要强制转换为适当的指针类型。
语法：
void* malloc(size_t size);例如，创建一个动态分配的整型数组：
#include <stdio.h>
#include <stdlib.h>
int main() {
int n; // 数组的大小
printf("Enter the number of elements: ");
scanf("%d", &n);
// 动态分配一个包含 n 个整数的数组
int* array = (int*) malloc(n * sizeof(int));
// 检查内存分配是否成功
if (array == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// 使用数组
for (int i = 0; i < n; i++) {
array[i] = i + 1; // 示例填充数组
}
// 打印数组
for (int i = 0; i < n; i++) {
printf("%d ", array[i]);
}
printf("\n");
// 释放内存
free(array);
return 0;
}malloc 分配 n * sizeof(int) 个字节，用于存储 n 个整数。malloc 返回 NULL，程序可以通过这个指针检查分配是否成功。free() 来释放分配的内存。calloc 分配动态数组：calloc 是另一种动态内存分配函数，它会将分配的内存初始化为零。
语法：
void* calloc(size_t num, size_t size);例如：
int* array = (int*) calloc(n, sizeof(int));calloc 与 malloc 的主要区别是，calloc 分配的内存会被初始化为零，而 malloc 分配的内存是未初始化的。
realloc 调整动态数组大小：
如果你需要调整动态数组的大小，可以使用 realloc 函数。它会重新分配内存，保留原有的数据内容。
语法：
void* realloc(void* ptr, size_t new_size);例如：
array = (int*) realloc(array, new_size * sizeof(int));realloc 接收一个指向之前分配内存的指针 ptr 和新的大小 new_size。realloc 返回 NULL，原来的内存块依然有效。realloc 调整数组大小#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 5;
int* array = (int*) malloc(n * sizeof(int));
// 填充数组
for (int i = 0; i < n; i++) {
array[i] = i + 1;
}
printf("Original array: ");
for (int i = 0; i < n; i++) {
printf("%d ", array[i]);
}
printf("\n");
// 调整数组大小
int new_size = 10;
array = (int*) realloc(array, new_size * sizeof(int));
// 为新数组的元素赋值
for (int i = n; i < new_size; i++) {
array[i] = i + 1;
}
printf("Resized array: ");
for (int i = 0; i < new_size; i++) {
printf("%d ", array[i]);
}
printf("\n");
// 释放内存
free(array);
return 0;
}malloc 或 calloc 来分配动态数组，使用 realloc 来调整数组大小。free() 来释放内存。在 C++17 及之后的版本中，标准库中引入了一个内置的 gcd 函数，用于计算两个整数的最大公约数（GCD）。它位于 <numeric> 头文件中，并使用欧几里得算法来高效地计算 GCD。
该函数位于 std 命名空间下，函数签名如下：
template <class T>
T gcd(T a, T b);int、long、long long 等。#include <iostream>
#include <numeric> // 包含 gcd 函数
#include <vector>
int main() {
int a = 56;
int b = 98;
// 使用 C++17 的内置 gcd 函数
int result = std::gcd(a, b);
std::cout << "GCD of " << a << " and " << b << " is " << result << std::endl;
return 0;
}GCD of 56 and 98 is 14std::gcd 函数使用的是经过优化的欧几里得算法，能够高效地计算两个整数的最大公约数。std::gcd 来计算各种整数类型的 GCD，包括 int、long、long long，甚至自定义类型，只要它们遵循整数类型的基本规则。你可以利用 std::gcd 来计算多个数的 GCD。假设我们想要计算一个数组中所有元素的 GCD，可以像这样结合 std::gcd 和 std::accumulate：
#include <iostream>
#include <numeric> // 包含 gcd 和 accumulate 函数
#include <vector>
int main() {
std::vector<int> nums = {56, 98, 42};
// 使用 accumulate 来计算多个数的 GCD
int result = std::accumulate(nums.begin(), nums.end(), nums[0], std::gcd<int, int>);
std::cout << "GCD of the array is " << result << std::endl;
return 0;
}GCD of the array is 14在标准的 C 语言库中（如 stdio.h 或 stdlib.h），没有内置的 gcd 函数。因此，如果需要在 C 语言中计算两个整数的最大公约数（GCD），你需要自己编写该函数。
long long gcd(long long a,long long b)
{
while(a != b)
{
if(a > b)
{
a = a - b;
}
else
{
b = b - a;
}
}
return a; // 返回a或b，因为最后它们相等并且是GCD
}在每次循环中通过减法逐步接近两个数的最大公约数，源于“更相减损术”的原理。这种方法可以追溯到古代的数学家欧几里得，并且可以用来证明两个数的最大公约数在减法中逐渐逼近。
这段代码的目的是计算两个数 a 和 b 的最大公约数（GCD，Greatest Common Divisor）以下是对代码的解释：
while 循环执行的是一种较原始的 GCD 计算方法，称为“减法法”。它通过逐步减少两个数的值直到它们相等。
aa 和 bb 的大小。如果 aa 大于 bb，就用 aa - bb 更新 aa，否则用 bb - aa 更新 bb。最终，aa 和 bb 会变成相等的数，而这个数就是它们的最大公约数。假设我们有两个数 a 和 b，且 a > b。在减法法中，我们每次用较大的数减去较小的数，直到两个数相等。以下是这种方法的核心思想：
保持最大公约数不变：
d 是 a 和 b 的最大公约数，即 d = gcd(a, b)，这意味着 a 和 b 都可以被 d 整除（即 a = d * m，b = d * n，其中 m 和 n 是整数）。a 减去较小的数 b 后，得到的新数 a' = a - b。a' = a - b 仍然可以被 d 整除，因为：a' 也是 d 的倍数，仍然与 b 有相同的最大公约数。收敛到最大公约数：
(a', b) 或 (a, b') 的差值越来越小。最终，两个数会变得相等，而这个相等的数就是 a 和 b 的最大公约数。aa = bb）就是它们的最大公约数。假设 a = 24，b = 18，我们通过每次减法逐步计算最大公约数：
a = 24, b = 18，因为 a > b，所以 a = a - b = 24 - 18 = 6。a = 6, b = 18，因为 b > a，所以 b = b - a = 18 - 6 = 12。a = 6, b = 12，因为 b > a，所以 b = b - a = 12 - 6 = 6。a = b = 6，所以最大公约数是 6。每一步中，最大公约数一直保持不变，直到最后两个数相等为止，而这个相等的数就是最大公约数。
实际计算 GCD 可以使用 欧几里得算法，它比这种减法法更高效。改进后的代码如下：
long long gcd(long long a,long long b)
{
if(b == 0)
return a;
return gcd(b, a % b); // 欧几里得算法
}除了递归，你也可以用迭代的方式实现：
#include <iostream>
long long gcd(long long a, long long b) {
while (b != 0) {
long long temp = b;
b = a % b;
a = temp;
}
return a;
}a % b 计算出 a 除以 b 的余数，接着交换 a 和 b 的值，继续计算，直到 b 为 0。这个实现方法比使用减法的方式更高效，尤其对于较大的数。
欧几里得算法（Euclidean algorithm）是一个用于计算两个整数的最大公约数（GCD，Greatest Common Divisor）的经典算法。它的基本原理是基于一个非常重要的数学定理：
若 d 是 a 和 b 的最大公约数，则 d 也是 b 和 a % b 的最大公约数。
设 a 和 b 是两个整数，且 a > b，则可以写成如下的关系：
a = b * q + r
其中：
q 是商（整数），r 是余数，即 r = a % b。根据这个关系式，可以重写为：
r = a - b * q
现在，让我们从 d = gcd(a, b) 出发进行推导，假设 d 是 a 和 b 的最大公约数。根据最大公约数的定义：
d 可以整除 a，即 a = d * m，其中 m 是某个整数。d 也可以整除 b，即 b = d * n，其中 n 是某个整数。接下来，我们要证明 d 也可以整除 r（即 a % b）。根据前面的等式：
r = a - b * q
代入 a = d * m 和 b = d * n：
r = d m - (d n) * q
r = d (m - n q)
因此，r 是 d 的倍数，这说明 d 也整除 r。
d 整除 b，并且 d 也整除 r，根据最大公约数的定义，d 是 b 和 r 的公约数。d = gcd(b, r)，而 r = a % b，这就证明了：这个过程可以重复，直到余数为 0。此时，剩下的数就是 a 和 b 的最大公约数。
a 和 b，其中 a > b。gcd(a, b) 等于 gcd(b, a % b)。换句话说，较大的数 a 可以被较小的数 b 除尽，并且我们继续用 a 除以 b 的余数来替换 a。b 和 a % b 作为新的一对数，直到其中一个数变为 0。欧几里得算法的核心思想是基于一个重要的数学定理，这个定理解释了为什么最大公约数（GCD）可以通过 a 和 b 转换为 b 和 a % b 来计算。下面是这个定理的详细解释。
a 替换为 a % b，并不断计算余数，最终将问题缩小。d 可以同时整除 b 和 a % b，因此 gcd(a, b) 可以递归地转换为 gcd(b, a % b)。b 就是 a 和 b 的最大公约数。这个定理和算法的关键在于利用了“除法余数不影响公约数”的特性，使得我们可以通过递归或迭代高效地计算出最大公约数。
另：求最小公倍数的方法：
另两数相乘然后除以最大公约数。
tip：为了防止爆int可以先除，再乘。
C++ 标准库中的 sort 函数是一个非常常用的函数，用来对序列进行排序。它位于头文件 <algorithm> 中。sort 函数使用了一种混合了快速排序、插入排序和堆排序的算法（通常是 introsort），在最坏情况下的时间复杂度为 O(n log n)，而最好的情况下是 O(n log n) 或 O(n)。
template< class RandomIt >
void sort( RandomIt first, RandomIt last );
template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );first 是序列的开始迭代器，last 是序列的结束迭代器，排序的范围为 [first, last)，注意 last 是不包含在排序范围内的。< 运算符）。如果你想自定义排序规则，例如降序或基于某个属性排序，可以传入这个函数对象。#include <iostream>
#include <algorithm> // 包含 sort 函数
#include <vector>
int main() {
std::vector<int> nums = {4, 2, 8, 5, 7, 1};
// 使用默认的升序排序
std::sort(nums.begin(), nums.end());
std::cout << "Sorted in ascending order: ";
for (int n : nums) {
std::cout << n << " ";
}
std::cout << std::endl;
return 0;
}Sorted in ascending order: 1 2 4 5 7 8#include <iostream>
#include <algorithm>
#include <vector>
int main() {
std::vector<int> nums = {4, 2, 8, 5, 7, 1};
// 使用自定义的降序比较函数
std::sort(nums.begin(), nums.end(), std::greater<int>());
std::cout << "Sorted in descending order: ";
for (int n : nums) {
std::cout << n << " ";
}
std::cout << std::endl;
return 0;
}Sorted in descending order: 8 7 5 4 2 1你可以定义一个自己的比较函数来排序。例如，假设我们有一个自定义的结构体，并且想要基于某个字段进行排序：
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
struct Person {
std::string name;
int age;
};
// 自定义比较函数，按 age 排序
bool compareByAge(const Person& a, const Person& b) {
return a.age < b.age; // 按年龄升序
}
int main() {
std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}};
// 使用自定义比较函数排序
std::sort(people.begin(), people.end(), compareByAge);
std::cout << "Sorted by age: \n";
for (const Person& person : people) {
std::cout << person.name << ": " << person.age << "\n";
}
return 0;
}Sorted by age:
Bob: 25
Alice: 30
Charlie: 35sort 函数提供了灵活的排序功能，既可以使用默认的升序排序，也可以通过自定义比较函数实现各种自定义排序逻辑。sort 适用于随机访问迭代器，因此可以对 std::vector、std::array 等容器进行排序。stable_sort，它是稳定排序，能保持相同元素的原有顺序。调和级数（Harmonic Series）是一种数学级数，它的形式为：
即：调和级数的第 n 项为前 n 个倒数的和。
虽然调和级数的每一项越来越小，但由于它是一个发散级数，尽管增长速度很慢，和仍然是无限大的。当 n 足够大时，
的值会逐渐逼近 
（其中 γ\gammaγ 是欧拉常数，大约为 0.577）。
简单来说，调和级数是描述一连串倒数相加的数列，随着项数增加，虽然每项越来越小，但总和会逐渐变大。