目录
第一章
算法的定义
算法（algorithm）是指在解决问题时，按照某种机械步骤一定可以得到问题结果的处理过程。
算法的三要素
算法由操作、控制结构、数据结构3要素组成。
算法的基本性质
目的性、分步性、有序性、有限性、操作性
算法的时间复杂度数量级：
常数，对数，幂函数，指数，阶乘
第二章
兔子繁殖问题（递推法）
一对兔子从出生后第三个月开始，每月生一对小兔子。小兔子到第三个月又开始生下一代小兔子。假若兔子只生不死，一月份抱来一对刚出生的小兔子，问1年中每个月各有多少对兔子。
#include <iostream>
int main() {
int adult = 0; // 成年兔子对数
int young = 1; // 未成年兔子对数
// 计算每个月的兔子对数
for (int month = 1; month <= 12; ++month) {
std::cout << "第 " << month << " 个月：" << adult + young << " 对兔子" << std::endl;
int new_adult = young; // 本月成年兔子来自上个月的未成年兔子
int new_young = adult; // 本月未成年兔子来自上个月的成年兔子
adult = new_adult; // 更新成年兔子对数
young = new_young + young; // 更新未成年兔子对数
}
return 0;
}猴子吃桃问题（递推法）
一只小猴子摘了若干桃子，每天吃现有桃的一半多一个，到第10天时就只有一个桃子了，求原有多少个桃？
#include <iostream>
int main() {
int peaches = 1; // 第10天剩下的桃子数
// 逆推每天的桃子数
for (int day = 9; day >= 1; --day) {
peaches = (peaches + 1) * 2;
}
std::cout << "原有桃子数：" << peaches << std::endl;
return 0;
}穿越沙漠问题（递推法（倒推））
用一辆吉普车穿越1000公里的沙漠。吉普车的总装油量为500加仑，耗油率为1加仑/公里。由于沙漠中没有油库，必须先用这辆车在沙漠中建立临时油库。该吉普车以最少的耗油量穿越沙漠，应在什么地方建油库，以及各处的贮油量。
#include <iostream>
int main() {
const int total_distance = 1000; // 总距离
const int total_gas = 500; // 总装油量
int min_gas = total_gas; // 最少耗油量
int gas_station = 0; // 油库位置
// 从终点开始逆向计算
for (int i = total_distance; i >= 0; --i) {
int remaining_gas = total_gas - i; // 到达位置 i 后的剩余油量
int current_gas = remaining_gas + (total_distance - i) * 2; // 当前位置建库的耗油量
if (current_gas < min_gas) {
min_gas = current_gas;
gas_station = i;
}
}
std::cout << "在距离出发点 " << gas_station << " 公里处建立临时油库，存储 " << total_gas - gas_station << " 加仑的油。" << std::endl;
return 0;
}百钱百鸡问题（蛮力法）
鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。百钱买百鸡，问鸡翁、母、雏各几何？
#include <iostream>
int main() {
for (int cock = 0; cock <= 20; ++cock) { // 鸡翁数量范围为0到20
for (int hen = 0; hen <= 33; ++hen) { // 鸡母数量范围为0到33
int chick = 100 - cock - hen; // 鸡雏数量为100减去鸡翁和鸡母数量
// 计算总价值
int total_value = cock * 5 + hen * 3 + chick / 3;
// 检查是否符合条件
if (total_value == 100 && chick % 3 == 0) {
std::cout << "鸡翁：" << cock << " 只，鸡母：" << hen << " 只，鸡雏：" << chick << " 只。" << std::endl;
}
}
}
return 0;
}数字谜问题（蛮力法）
编写算法解如下数字迷。
A B C A B
×
A
————————
D D D D D D
第三章
递归算法的设计步骤及其优缺点 设计步骤：
（1）分析并划分问题：将问题分解成若干个规模较小、相互独立，但类型相同的子问题。需 要注意的是各子问题的解必须能够组合成原始问题的一个完整答案。
（2）设计递归函数：根据步骤（1）问题分解的过程，设计出相应的递归函数。设计递归函数 时需要注意两个要素：边界条件和递归方程，递归函数只有具备了这两个要素，才能在有限次 计算后得出结果。
（3）设计程序：根据递归函数设计出解决问题的程序。 优缺点： 优点：结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、 调试程序带来很大方便。 缺点：递归算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多
二分查找算法执行过程？
（1）将待查找的数据与非降序数组中的中间元素进行比较，若二者相等则表示查到；
（2）若该数据小于中间元素的值，则下次在数组的前半部分中继续找；
（3）否则，在数组的后半部分中查找;
（4）即每次查找将与待查数据的比较次数减半,如此继续进行下去，直到查到该值的元素或不存在所查找的数据。
分治算法的基本步骤？
将整个问题分解成若干个小问题后再分而治之。
（1）分解：将原问题分解为若干个规模较小，相互独立，与原问 题形式相同的子问题。
（2）解决：若子问题规模较小而容易被解决则直接解，否则再继 续分解为更小的子问题，直到容易解决。
（3）合并：将已求解的各个子问题的解，逐步合并为原问题的解。
残缺棋盘问题（分治法）
残缺棋盘是一个有2k×2k （k≥1）个方格的棋盘，其中恰有一个方格残缺。图3-1给出k=1时各种可能的残缺棋盘，其中残缺的方格用阴影表示。这样的棋盘我们称作“三格板”。 残缺棋盘问题就是要用三格板覆盖更大的残缺棋盘。在此覆盖中要求： 1）两个三格板不能重叠； 2）三格板不能覆盖残缺方格，但必须覆盖其他所有的方格
最大子段和（动态规划）
最大子段和问题：给定由n个数组成的序列a1，a2，……，an，序列中可能有负数，要在这n个数中选取相邻的一段ai， ai+1，……，aj（1≤i≤j≤n）使其和最大，并输出最大和。当所有的数均为负数时，定义最大子段和为0。其中数据个数n和n个数据都通过键盘输入（动态规划算法实现）。
金块问题（分治法）
#include <iostream> #include <vector> // 比较两个金块的重量 int compare(int a, int b) { if (a > b) return 1; if (a < b) return -1; return 0; } // 在给定范围内找到最重的金块 int find_heaviest(const std::vector<int>& gold, int low, int high) { if (low == high) return gold[low]; // 只有一个金块，直接返回 int mid = (low + high) / 2; int left_heaviest = find_heaviest(gold, low, mid); // 左半部分的最重金块 int right_heaviest = find_heaviest(gold, mid + 1, high); // 右半部分的最重金块 // 比较左右两部分的最重金块 return compare(left_heaviest, right_heaviest) > 0 ? left_heaviest : right_heaviest; } int main() { std::vector<int> gold = {3, 7, 2, 10, 5, 8}; // 金块重量列表 int n = gold.size(); int heaviest_gold = find_heaviest(gold, 0, n - 1); std::cout << "最重的金块重量为：" << heaviest_gold << std::endl; return 0; }求第二小元素问题（分治法）
求一组数的第二小的数。
#include <iostream> #include <vector> #include <limits> // 函数：找到一组数的第二小的数 int find_second_min(const std::vector<int>& nums) { // 初始化第一小的数和第二小的数为无穷大 int first_min = std::numeric_limits<int>::max(); int second_min = std::numeric_limits<int>::max(); // 遍历数组，更新第一小和第二小的数 for (int num : nums) { if (num < first_min) { // 如果当前数字小于第一小的数，则更新第二小的数为第一小的数，更新第一小的数为当前数字 second_min = first_min; first_min = num; } else if (num < second_min && num != first_min) { // 如果当前数字大于第一小的数但小于第二小的数，则更新第二小的数为当前数字 second_min = num; } } return second_min; // 返回第二小的数 } int main() { // 提示用户输入一组数 std::cout << "请输入一组数（以空格分隔）: "; // 读取用户输入的一组数 std::vector<int> nums; int num; while (std::cin >> num) { nums.push_back(num); } // 找到第二小的数并输出 int second_min = find_second_min(nums); std::cout << "第二小的数是：" << second_min << std::endl; return 0; }
第四章
贪心算法的设计思想
贪心算法的基本思想是找出整体当中每个小的局部的最优解，并且将所有的这些局部最优解合起来形成整体上的一个最优解。
因此能够使用贪心算法的问题必须满足下面的两个性质：
（1）整体的最优解可以通过局部的最优解来求出；
（2）一个整体能够被分为多个局部，并且这些局部都能够求出最优解。
贪心算法设计思想与动态规划算法设计思想，以及他们之间的区别？
贪心算法的设计思想是每一步选择当前状态下的最优解，期望通过一系列局部最优解得到全局最优解。动态规划算法的设计思想是将问题分解为相互重叠的子问题，并通过求解这些子问题，最终得到原问题的解。贪心算法通常更简单高效，但可能无法得到全局最优解；动态规划算法可以解决一些贪心算法无法解决的问题，但实现更复杂，需要额外空间来存储中间结果。贪心算法是自顶向下，动态规划是自底向上方式求解各个子问题。
👌删除数字问题（贪心算法）
键盘输入一个高精度的正整数n，去掉其中任意s个数字后剩下的数字按原左右次序将组成一个新的正整数。编程对给定的n和s，寻找一种方案使得剩下的数字组成的新数最小。
#include <iostream>
#include <string>
std::string removeDigits(const std::string& n, int s) {
std::string result;
for (char digit : n) {
while (s > 0 && !result.empty() && result.back() > digit) {
result.pop_back();
--s;
}
result.push_back(digit);
}
// 删除剩余的 s 个数字
result.resize(result.size() - s);
// 去除前导零
int pos = 0;
while (pos < result.size() && result[pos] == '0') {
++pos;
}
result = result.substr(pos);
return result.empty() ? "0" : result;
}
int main() {
std::string n;
int s;
std::cout << "请输入一个正整数 n 和需要删除的数字个数 s：" << std::endl;
std::cin >> n >> s;
std::string newNumber = removeDigits(n, s);
std::cout << "去掉 " << s << " 个数字后剩下的数字组成的新数是：" << newNumber << std::endl;
return 0;
}数列极差问题（贪心算法）
在黑板上写了N个正整数作成的一个数列，进行如下操作:每一次擦去其中的两个数a和b，然后在数列中加入一个数a×b+1，如此下去直至黑板上剩下一个数，在所有按这种操作方式最后得到的数中，最大的记作max，最小的记作min，则该数列的极差定义为M=max-min。
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
// 计算数列的极差
int calculateRange(const std::vector<int>& nums) {
std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap(nums.begin(), nums.end());
std::priority_queue<int, std::vector<int>, std::less<int>> max_heap(nums.begin(), nums.end());
while (min_heap.size() > 1) {
int a = min_heap.top();
min_heap.pop();
int b = min_heap.top();
min_heap.pop();
min_heap.push(a * b + 1);
}
while (max_heap.size() > 1) {
int a = max_heap.top();
max_heap.pop();
int b = max_heap.top();
max_heap.pop();
max_heap.push(a * b + 1);
}
int min = min_heap.top();
int max = max_heap.top();
return max - min;
}
int main() {
int n;
std::cout << "请输入数列的长度 n：" << std::endl;
std::cin >> n;
std::vector<int> nums(n);
std::cout << "请输入 " << n << " 个正整数：" << std::endl;
for (int i = 0; i < n; ++i) {
std::cin >> nums[i];
}
int range = calculateRange(nums);
std::cout << "数列的极差为：" << range << std::endl;
return 0;
}币种问题（贪心算法）
某单位给每个职工发工资（精确到元）。为了保证不要临时兑换零钱, 且取款的张数最少，取工资前要统计出所有职工的工资所需各种币值(100,50,20,10,5,2,1元共七种)的张数。请编程完成。
#include <iostream>
#include <vector>
// 计算每个职工工资所需各种面额的张数
std::vector<std::vector<int>> calculateSalaryBills(const std::vector<int>& salaries) {
// 定义面额数组
std::vector<int> denominations = {100, 50, 20, 10, 5, 2, 1};
std::vector<std::vector<int>> bills(salaries.size(), std::vector<int>(denominations.size(), 0));
// 对每个职工的工资进行处理
for (int i = 0; i < salaries.size(); ++i) {
int salary = salaries[i];
// 遍历面额数组
for (int j = 0; j < denominations.size(); ++j) {
int denomination = denominations[j];
// 计算当前面额需要的张数
int count = salary / denomination;
// 更新剩余工资
salary -= count * denomination;
// 记录当前面额的张数
bills[i][j] = count;
}
}
return bills;
}
int main() {
// 输入每个职工的工资
int n;
std::cout << "请输入职工人数：";
std::cin >> n;
std::vector<int> salaries(n);
std::cout << "请输入每个职工的工资（以空格分隔）：";
for (int i = 0; i < n; ++i) {
std::cin >> salaries[i];
}
// 计算各种面额的张数
std::vector<std::vector<int>> bills = calculateSalaryBills(salaries);
// 输出结果
std::cout << "各个职工工资所需各种币值的张数：" << std::endl;
for (int i = 0; i < n; ++i) {
std::cout << "第 " << i + 1 << " 个职工：" << std::endl;
for (int j = 0; j < bills[i].size(); ++j) {
std::cout << bills[i][j] << " 张 " << (j == 0 ? "100" : std::to_string(bills[i][j])) << " 元；";
}
std::cout << std::endl;
}
return 0;
}取数游戏（贪心算法）
有2个人轮流取2n个数中的n个数，取数之和大者为胜。请编写算法，让先取数者胜，模拟取数过程。 游戏规则：这个游戏规定取数者只能看到2n个数中两端的数。
#include <iostream>
#include <vector>
// 模拟游戏过程
int playGame(const std::vector<int>& nums) {
int n = nums.size() / 2; // 总数的一半
int first_player_score = 0;
int second_player_score = 0;
for (int i = 0; i < n; ++i) {
// 先取数者选择较大的数
if (nums[i] > nums[nums.size() - i - 1]) {
first_player_score += nums[i];
} else {
second_player_score += nums[nums.size() - i - 1];
}
}
// 返回先取数者的得分
return first_player_score;
}
int main() {
// 输入2n个数
int n;
std::cout << "请输入2n个数：" << std::endl;
std::cin >> n;
std::vector<int> nums(2 * n);
for (int i = 0; i < 2 * n; ++i) {
std::cin >> nums[i];
}
// 模拟游戏过程并输出结果
int first_player_score = playGame(nums);
std::cout << "先取数者的得分为：" << first_player_score << std::endl;
return 0;
}第五章
动态规划基本思想
基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解
两个基本要素
最优子结构性质和子问题重叠性质。
四个步骤
（1）分析最优子结构性质 是基础，也是关键。子问题的分解和对应的的子问题描述是关键。 （2）递归地定义最优值 是动态规划算法的核心，它是最优解的规划过程。
（3）以自底向上的方式计算出最优值 体现了动态规划算法的执行过程。
（4）构造最优解 是可选步骤，只有问题要求构造最优解时才需要
0－1背包问题（动态规划）
给定一个物品集合s＝｛1，2，3，…，n｝，物品i的重量是wi，其价值是vi，背包的容量为W，即最大载重量不超过W。在限定的总重量W内，我们如何选择物品，才能使得物品的总价值最大。
#include <iostream>
#include <vector>
#include <algorithm>
int knapsack(int W, const std::vector<int>& weights, const std::vector<int>& values) {
int n = weights.size();
std::vector<std::vector<int>> dp(n + 1, std::vector<int>(W + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= W; ++j) {
if (weights[i - 1] > j) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] = std::max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]);
}
}
}
return dp[n][W];
}
int main() {
int n, W;
std::cout << "请输入物品个数 n 和背包容量 W：" << std::endl;
std::cin >> n >> W;
std::vector<int> weights(n);
std::vector<int> values(n);
std::cout << "请输入每个物品的重量和价值：" << std::endl;
for (int i = 0; i < n; ++i) {
std::cin >> weights[i] >> values[i];
}
int max_value = knapsack(W, weights, values);
std::cout << "在背包容量为 " << W << " 的情况下，可以获得的最大总价值为：" << max_value << std::endl;
return 0;
}最大子段和（动态规划）
最大子段和问题：给定由n个数组成的序列a1，a2，……，an，序列中可能有负数，要在这n个数中选取相邻的一段ai， ai+1，……，aj（1≤i≤j≤n）使其和最大，并输出最大和。当所有的数均为负数时，定义最大子段和为0。其中数据个数n和n个数据都通过键盘输入（动态规划算法实现）。
#include <iostream>
#include <vector>
int maxSubArray(const std::vector<int>& nums) {
int n = nums.size();
if (n == 0) return 0;
int max_sum = nums[0]; // 最大子段和
int current_sum = nums[0]; // 当前子段和
for (int i = 1; i < n; ++i) {
// 更新当前子段和
current_sum = std::max(current_sum + nums[i], nums[i]);
// 更新最大子段和
max_sum = std::max(max_sum, current_sum);
}
return max_sum;
}
int main() {
int n;
std::cout << "请输入数据个数 n：" << std::endl;
std::cin >> n;
std::vector<int> nums(n);
std::cout << "请输入 " << n << " 个数据：" << std::endl;
for (int i = 0; i < n; ++i) {
std::cin >> nums[i];
}
int max_sum = maxSubArray(nums);
std::cout << "最大子段和为：" << max_sum << std::endl;
return 0;
}数字三角形（动态规划）
数字三角形问题：如下图是一个数字三角形，从顶部出发在每一个节点可以选择向左或者向右走，一直走到底层，要求找出一条路径，使得路径上的数字之和最大。（动态规划算法设计）
第六章
回溯法的定义
以深度优先的方式系统地搜索问题的解的方法称为回溯法。
回溯法两大特性
系统性 回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。
跳跃性 算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。
回溯法的基本思想
回溯法的基本步骤
(1)针对所给问题，定义问题的解空间；
(2)确定易于搜索的解空间结构；
(3)以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。
子集树与排列树
子集树 从n个元素的集合S中找出S满足某种性质的子集，相应的解空间称为子集树。通常有2n个叶结点，结点总数为2n+1-1。需Ω(2n)计算时间。 如n个物品的0-1背包问题的解空间是一棵子集树。
排列树 当所给问题的确定n个元素满足某种性质的排列时，相应的解空间树称为排列树。排列树通常有n!个叶结点。因此遍历排列树需要Ω(n!)计算时间。 TSP(旅行售货员问题)的解空间是一棵排列树。
八皇后问题（回溯）
八皇后问题：在8×8的国际象棋盘上，放置8个皇后，使任何一个皇后都不能吃掉其他皇后,要使任何一个皇后都不能吃掉其他皇后需满足的条件是：同一行、同一列、同一对角线上只能有一个皇后，求放置方法。 （回溯法设计）
#include <iostream>
#include <vector>
bool isValid(const std::vector<int>& queens, int row, int col) {
// 检查当前列是否已经有皇后
for (int i = 0; i < row; ++i) {
if (queens[i] == col || std::abs(i - row) == std::abs(queens[i] - col)) {
return false;
}
}
return true;
}
void solveNQueens(std::vector<std::vector<int>>& solutions, std::vector<int>& queens, int row, int n) {
if (row == n) {
solutions.push_back(queens);
return;
}
for (int col = 0; col < n; ++col) {
if (isValid(queens, row, col)) {
queens[row] = col;
solveNQueens(solutions, queens, row + 1, n);
}
}
}
void printSolution(const std::vector<int>& queens) {
int n = queens.size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
std::cout << (queens[i] == j ? "Q" : ".");
std::cout << " ";
}
std::cout << std::endl;
}
std::cout << std::endl;
}
int main() {
int n = 8; // 8×8 的棋盘
std::vector<std::vector<int>> solutions;
std::vector<int> queens(n, 0); // queens[i] 表示第 i 行皇后所在的列
solveNQueens(solutions, queens, 0, n);
// 输出所有解
std::cout << "八皇后问题的所有解：" << std::endl;
for (const auto& solution : solutions) {
printSolution(solution);
}
return 0;
}