一、重新安排行程
1.题目
Leetcode：第 332 题
给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。
所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
- 例如，行程
["JFK", "LGA"]与["JFK", "LGB"]相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。
示例 1：
输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]] 输出：["JFK","MUC","LHR","SFO","SJC"]
示例 2：
输入：tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]] 输出：["JFK","ATL","JFK","SFO","ATL","SFO"] 解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"] ，但是它字典排序更大更靠后。
2.解题思路
使用回溯算法来解决路径问题。findItinerary 函数负责初始化并开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个位置添加一个城市，并递归地继续处理后续的城市。通过这种方式，backtracking 函数能够找到一条有效的旅行路径。targets 映射用于存储每个出发城市到到达城市的机票数量，这个映射在 findItinerary 函数中被构建，并在 backtracking 函数中被用来检查是否存在可用的机票。通过递归和回溯来搜索所有可能的解决方案。当找到一个满足条件的解时，递归返回 true，否则尝试其他可能的路径。
3.实现代码
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
using namespace std;
class Solution {
public:
// 使用 unordered_map 存储目标城市，其中 key 为出发城市，value 为一个 map，其 key 为到达城市，value 为机票数量
unordered_map<string, map<string, int>> targets;
// backtracking 函数实现回溯算法，尝试找出一条有效的旅行路径
bool backtracking(int ticketNum, vector<string>& result) {
// 如果当前路径长度等于机票数量加一（包括起点城市），说明找到了一条完整的路径
if (result.size() == ticketNum + 1) {
return true;
}
// 遍历当前结果路径最后一个城市的所有可到达城市
for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
// 如果从当前城市到 target.first 的机票数量大于 0
if (target.second > 0) {
result.push_back(target.first);// 将 target.first 添加到结果路径中
target.second--;// 减少 target.first 的机票数量
if (backtracking(ticketNum, result)) return true; // 递归调用 backtracking 函数，尝试继续添加路径
result.pop_back();// 如果当前路径不可行，回溯：移除最后一个添加的城市
target.second++;// 恢复机票数量
}
}
return false;// 如果所有可能的路径都已经尝试过，但没有找到可行的路径，则返回 false
}
// findItinerary 函数用于找出一条最短的旅行路径
vector<string> findItinerary(vector<vector<string>>& tickets) {
targets.clear(); // 清空 targets，为新的机票数据做准备
vector<string> result;
// 统计每个出发城市到到达城市的机票数量
for (const vector<string>& vec : tickets) {
targets[vec[0]][vec[1]]++;
}
result.push_back("JFK");// 将起点城市 "JFK" 添加到结果路径中
backtracking(tickets.size(), result);// 从起点城市开始，使用 backtracking 函数尝试找出一条旅行路径
return result; // 返回找到的旅行路径
}
};
//测试
int main()
{
Solution p;
vector<vector<string>>tickets = { {"MUC", "LHR"} ,{"JFK", "MUC"},{"SFO", "SJC"},{"LHR", "SFO"} };
vector<string> result;
vector<int>nums = { 1,2,2 };
result = p.findItinerary(tickets);
cout << "行程：" << endl;
for (auto& ans : result) {
cout << "[";
for (auto& i : ans) {
cout << i << " ";
}
cout << "] ," ;
}
printf("\b \n");
return 0;
}
二、N皇后
1.题目
Leetcode：第 51 题
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例 1：
输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1 输出：[["Q"]]
2.解题思路
使用回溯算法来解决棋盘问题。solveNQueens 函数负责初始化棋盘并开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个位置放置皇后，并递归地继续处理后续的行。isValid 函数用于检查当前位置是否安全，即没有受到其他皇后的攻击。backtracking 函数通过递归尝试每一行的每一个位置来放置皇后。如果找到一个安全的位置，它将继续递归到下一行。如果这一行的所有位置都尝试过了，它将回溯到上一行，改变上一行皇后的位置。isValid 函数通过检查当前行的列、左上到右下的对角线、右上到左下的对角线是否有皇后来确定当前位置是否安全。这种方法可以找到所有可能的解决方案，即所有安全的皇后放置方式。
3.实现代码
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
vector<vector<string>> result;// 定义一个二维字符串数组用于存储所有可能的棋盘布局结果
// backtracking 函数实现回溯算法，尝试放置每一行的皇后
void backtracking(int n, int row, vector<string>& chessboard) {
// 如果当前行数等于 n，说明已经放置完所有行的皇后，找到了一个解决方案
if (row == n) {
result.push_back(chessboard);
return;
}
// 遍历当前行的每一个列
for (int col = 0; col < n; col++) {
// 检查当前位置是否有效，即该位置没有受到其他皇后的攻击
if (isValid(row, col, chessboard, n)) {
chessboard[row][col] = 'Q'; // 在当前位置放置一个皇后
backtracking(n, row + 1, chessboard);// 递归调用 backtracking 函数，尝试放置下一行的皇后
chessboard[row][col] = '.';// 移除当前位置的皇后，回溯以便尝试其他位置
}
}
}
// isValid 函数用于检查当前行和列是否是安全的，即该位置没有受到其他皇后的攻击
bool isValid(int row, int col, vector<string>& chessboard, int n) {
// 检查列是否有其他皇后
for (int i = 0; i < row; i++) {
if (chessboard[i][col] == 'Q') {
return false; // 如果同一列有皇后，则返回 false
}
}
// 检查左上到右下的对角线是否有其他皇后
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (chessboard[i][j] == 'Q') {
return false; // 如果对角线有皇后，则返回 false
}
}
// 检查右上到左下的对角线是否有其他皇后
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false; // 如果对角线有皇后，则返回 false
}
}
return true;// 如果当前位置安全，则返回 true
}
// solveNQueens 函数用于开始解决 N 皇后问题
vector<vector<string>> solveNQueens(int n) {
result.clear();// 清空结果集，为新的棋盘布局做准备
vector<string> chessboard(n, string(n, '.')); // 初始化棋盘，所有位置先设为 '.'
backtracking(n, 0, chessboard);// 从第一行开始放置皇后
return result;// 返回所有可能的棋盘布局结果
}
};
//测试
int main()
{
Solution s;
int n;
vector<vector<string>>result;
cout << "请输入 n ： ";
cin >> n;
result = s.solveNQueens(n);
cout << "所有的解法有：" << endl;
for (int i = 0; i < result.size(); i++) {
cout << "第"<<i+1<<"种解法" << endl;
for (int j = 0; j < n; j++) {
cout << result[i][j] << " " << endl;
}
cout << endl;
}
cout <<endl;
return 0;
}
三、解数独
1.题目
Leetcode：第 37 题
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
- 数字
1-9在每一行只能出现一次。 - 数字
1-9在每一列只能出现一次。 - 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。
示例 1：
输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]] 输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]] 解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
2.解题思路
使用回溯算法来解决数独问题。solveSudoku 函数负责开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个空格填入数字，并递归地继续处理后续的空格。isValid 函数用于检查当前位置填入某个数字后数独板是否仍然有效。backtracking 函数通过递归尝试每个空格的每个可能的数字来解决数独问题。如果找到一个数字使得数独板有效，它将继续递归到下一个空格。如果当前空格的所有尝试都失败了，它将回溯到上一个空格，改变上一个空格的数字。isValid 函数通过检查当前行、当前列以及当前单元格所在的 3x3 子网格是否有重复的数字来确定当前位置是否有效。这种方法可以找到数独问题的解决方案，即使在复杂的数独谜题中也能有效地找到答案。
3.实现代码
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
// backtracking 函数实现回溯算法，尝试填入数独板的每个空格
bool backtracking(vector<vector<char>>& board) {
// 遍历数独板的每个单元格
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
// 如果当前单元格为空（'.'）
if (board[i][j] == '.') {
// 尝试填入数字 1 到 9
for (char k = '1'; k <= '9'; k++) {
// 如果填入当前数字 k 后数独板仍然有效
if (isValid(i, j, k, board)) {
// 在当前单元格填入数字 k
board[i][j] = k;
// 递归调用 backtracking 函数，尝试填入下一个空格
if (backtracking(board)) {
return true; // 如果找到一个解决方案，则返回 true
}
// 如果当前数字 k 不适用，回溯：将当前单元格重置为空
board[i][j] = '.';
}
}
return false;// 如果没有数字可以填入当前单元格，则返回 false
}
}
}
return true;// 如果所有单元格都已经填入数字并且数独板有效，则返回 true
}
// isValid 函数检查在给定的行和列填入某个值后数独板是否仍然有效
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
// 检查当前行是否已包含要填入的值 val
for (int i = 0; i < 9; i++) {
if (board[row][i] == val) {
return false; // 如果已包含，则返回 false
}
}
// 检查当前列是否已包含要填入的值 val
for (int j = 0; j < 9; j++) {
// 数独规则中，即使单元格为空（'.'），列中也不能有重复的数字
if (board[j][col] == val) {
return false; // 如果已包含，则返回 false
}
}
// 计算当前单元格所在的 3x3 子网格的起始行和列
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
// 检查当前 3x3 子网格是否已包含要填入的值 val
for (int i = startRow; i < startRow + 3; i++) {
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == val) {
return false; // 如果已包含，则返回 false
}
}
}
// 如果当前单元格填入 val 后不违反数独规则，则返回 true
return true;
}
// solveSudoku 函数用于解决数独问题
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);// 调用 backtracking 函数尝试填入数独板
}
};
//测试
int main()
{
Solution s;
vector<vector<char>> board = { {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
{'.', '.', '.', '.', '8', '.', '.', '7', '9'} };
s.solveSudoku(board);
cout << "数独的其中一种解法：" << endl;
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
cout << board[i][j] << " ";
}
cout << endl;
}
cout << endl;
cout << endl;
return 0;
}
ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。
![[leetcode] 56. 合并区间](https://img-blog.csdnimg.cn/direct/a36c1b59f2eb48eebd27dc7ba26116ca.png)
