332.重新安排行程(可跳过)
这道题关键是要在保证连续使用完全部的车票的情况下,尽量保证每次的目的地值尽量的小。主要需要判断出要使用什么样的储存方式。文章中给出的储存方式就很巧妙,使用unordered_map<string, map<string, int>>来储存信息,这样就可以做到根据form来准确找到哪些车票可以使用,然后根据map会自动给键从小到大排序,这样每次取出的票默认最小的目的地,然后根据值(int)来判断这张票是否还有剩余,如果没有再选择次小的(注意map类都需要使用迭代器来遍历)。
要事先给res数组装入默认出发地,这样只要保证每次递归函数调用只是装入目的地即可,这样就可以保证得到完整路线。注意一旦res数组的size==车票数量+1,就证明已经使用完全部车票(而不是恰好等于车票数量),因为在加入这张车票之前,需要判断加入了这张车票之后能不能保证使用完全部车票,也就是需要知道后续递归函数的结果,所以需要有bool返回值,一旦不能全部使用车票,就立即换用下一张可行车票,进一步如果将全部车票都用了,还是不行,那就返回false,而如果确实能得到最终结果,那就直接返回true不再继续试探。
因为map自动排好大小,所以每次一定是最先取出更优解,所以只要判断这个解行不行得通即可,这样一旦行得通,就证明已经得到结果。
class Solution {
private:
// unordered_map<出发机场, map<到达机场, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
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]]) {
if (target.second > 0 ) { // 记录到达机场是否飞过了
result.push_back(target.first);
target.second--;
if (backtracking(ticketNum, result)) return true;
result.pop_back();
target.second++;
}
}
return false;
}
public:
vector<string> findItinerary(vector<vector<string>>& tickets) {
targets.clear();
vector<string> result;
for (const vector<string>& vec : tickets) {
targets[vec[0]][vec[1]]++; // 记录映射关系
}
result.push_back("JFK"); // 起始机场
backtracking(tickets.size(), result);
return result;
}
};
51. N皇后(可跳过)
这道题是很经典的回溯问题,其实并不算特别难,只要把握回溯算法的精髓也能做出来。
首先要明白,需要传入一个path的string数组才储存每次的结果,并且需要全部2初始化为“....”,这样每次只要选出合适的位置来放Q即可。
其次要明白,要按照一行一行地来解决,这样首先就能保证一行不会出现两个Q,然后每一行(每次递归)要依次在每一个位置试探Q的位置,这样就需要传入要处理的行下标做参数,因为题目有多解要找到,所以一旦行下标==size,就直接收获结果,而且不需要返回值,因为不用特意终止递归,必须要每一个位置都试探过了才能收集到全部结果。
每次到了一行,如果试探到了一个可行位置,那就直接递归调用函数即可,调用完了,不用管这个位置是否真的是最终结果的Q的位置,都需要恢复原样,继续试探下一个位置。具体试探只要试探之前行的Q的位置即可,因为是一行一行地依次放Q。
class Solution {
public:
vector<vector<string>> res;
bool Judge(vector<string>& path,int x,int y){
//竖行:
for(int i=0;i<x;i++){
if(path[i][y]=='Q') return false;
}
//正斜线:
int i=x-1,j=y-1;
while((i>=0)&&(j>=0)){
if(path[i--][j--]=='Q') return false;
}
//负斜线:
i=x-1,j=y+1;
while((i>=0)&&(j<path.size())){
if(path[i--][j++]=='Q') return false;
}
return true;
}
void backtracking(vector<string>& path,int index){
if(index==path.size()){
res.push_back(path);
return ;
}
for(int i=0;i<path.size();i++){
if(!Judge(path,index,i)) continue;
path[index][i]='Q';
backtracking(path,index+1);
path[index][i]='.';
}
}
vector<vector<string>> solveNQueens(int n) {
string str;
for(int i=0;i<n;i++) str+=".";
vector<string> path(n,str);
backtracking(path,0);
return res;
}
};
37. 解数独(可跳过)
这道题的关键就是怎样合理地套用回溯模板。首先要明确,这道题和上一道N皇后问题是不同的,主要在于N皇后是每一行找一个位置来试探,虽然也说是棋盘,但实际上对于一种解决方案并不是一行的每一个位置都要填入数据,这样只需要一行一行来解决问题即可(使用一层for循环),而解决数独问题是要在每一行的每一个空格内都填入数据,这是不能按照一行一行来解决问题的,而是要按照一个空格、一个空格来解决问题,所以就是二维的(需要两层for循环)。也可以这样想,每次递归函数都一定要将每一个方格依次遍历,这样才能不漏掉,而没办法记录行下标或列下标,来直接简单地减少循环次数。
每遍历到一个未填入数字的空格的时候,需要依次将每一个数都填进去一遍来试探,如果合法,就直接再递归调用,如果能返回true那就证明已经得到结果,直接返回就可以了,这道题并不是多个结果,所以一旦填满空格就直接返回true即可(也就是for循环中遍历完都没有发现一个空格——出了for循环直接返回true)。所以应该是每次调用函数只填入一个空格,然后立马调用递归函数来填入下一个空格。
如果发现某次试探一个空格的时候,试探了所有合法的数字都不满足条件,那就证明上一个填入的数字是错的,所以这次函数直接返回false。
还有关于如何判断一个数字填在这里是否合法,要先不填,试探是否board里面已经出现了和要填入的数字相同的数字,如果已经填入了,那就返回false,反之就证明这个数字填在这里合法,返回true。然后一个巧妙的方法找到所在九宫格的起始下标的方法是直接 /3,再*3,这样除去了余数,就直接是起始下标了。
class Solution {
private:
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] == '.') {
for (char k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
if (isValid(i, j, k, board)) {
board[i][j] = k; // 放置k
if (backtracking(board)) return true; // 如果找到合适一组立刻返回
board[i][j] = '.'; // 回溯,撤销k
}
}
return false; // 9个数都试完了,都不行,那么就返回false
}
}
}
return true; // 遍历完没有返回false,说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
for (int i = 0; i < 9; i++) { // 判断行里是否重复
if (board[row][i] == val) {
return false;
}
}
for (int j = 0; j < 9; j++) { // 判断列里是否重复
if (board[j][col] == val) {
return false;
}
}
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == val ) {
return false;
}
}
}
return true;
}
public:
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);
}
};
总结
for循环横向遍历,递归纵向遍历,回溯不断调整结果集。
在for循环上做剪枝操作是回溯法剪枝的常见套路。
startIndex来控制for循环的起始位置——
如果是一个集合来求组合的话,就需要startIndex;如果是多个集合取组合,各个集合之间相互不影响,那么就不用startIndex。
去重问题——
“使用过”在这个树形结构上是有两个维度的,一个维度是同一树枝上“使用过”(往往要保留,也就是同一个解决方案可以出现相等的元素),一个维度是同一树层上“使用过”(往往是要去重的部分,也就是不同解决方案不能出现同一位置有两个相同元素)。树层去重,效率更高。
二维递归问题:解数独问题。