【回溯算法】回溯，从入门到入土，七道试题精选、精讲、精练

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

[[0,0,0,0,0,0,0,0]]

int checkIsland(vector<vector<int>>& grid, int x, int y) {
        int count = 0;
        if (grid[x][y] == 0)
            return count;
        else {
            grid[x][y] = 0;
            count++;
            //上
            if (x - 1 >= 0)
                count += checkIsland(grid, x - 1, y);
            //右
            if ((y + 1) < grid[0].size())
                count += checkIsland(grid, x, y + 1);
            //下
            if ((x + 1) < grid.size())
                count += checkIsland(grid, x + 1, y);
            //左
            if ((y - 1) >= 0)
                count += checkIsland(grid, x, y - 1);
        }
        return count;
    }

    int maxAreaOfIsland(vector<vector<int>>& grid) {
        if (grid.size() == 0)
            return 0;
        int max = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                int temp = checkIsland(grid, i, j);
                if (temp > max) {
                    max = temp;
                }
            }
        }
        return max;
    }

#include<iostream>

using namespace std;

#define MAX_NUM 8		//皇后数量

int queen[MAX_NUM][MAX_NUM] = { 0 };

bool check(int x, int y) {	//检查一个坐标是否可以放置
	for (int i = 0; i < y; i++) {
		if (queen[x][i] == 1) {	//这一行是否可以存在
			return false;
		}
		if (x - 1 - i > 0 && queen[x - 1 - i][y - 1 - i] == 1) {	//检查左斜列
			return false;
		}
		if (x + 1 + i < MAX_NUM && queen[x + 1 + i][y + 1 + i] == 1) {	//检查右斜列
			return false;
		}
	}
	queen[x][y] = 1;
	return true;
}

void showQueen() {
	for (int i = 0; i < MAX_NUM; i++) {
		for (int j = 0; j < MAX_NUM; j++) {
			cout << queen[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

bool settleQueen(int x) {
	if (x == MAX_NUM) {	//遍历完毕，找到答案
		return true;
	}
	for (int i = 0; i < MAX_NUM; i++) {
		for (int y = 0; y < MAX_NUM; y++) {
			queen[y][x] = 0;	//清空当前列，省的回溯的时候被打扰
		}
		if (check(i,x)) {	//如果这行找着了
			queen[i][x] = 1;
			showQueen();	//直观测试结果
			if (settleQueen(x + 1)) {	//是时候往左了
				return true;	//一路往左
			}
		}
	}
	return false;	//如果不行，就退回来
}

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

	vector<string> generateParenthesis(int n) {
        vector<string> res;
        generateParenthesisDFS(n, n, "", res);
        return res;
    }
    void generateParenthesisDFS(int left, int right, string out, vector<string> &res) {
        if (left > right) return;
        if (left == 0 && right == 0) res.push_back(out);
        else {
            if (left > 0) generateParenthesisDFS(left - 1, right, out + '(', res);
            if (right > 0) generateParenthesisDFS(left, right - 1, out + ')', res);
        }
    }

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

我们先写以 1 开头的全排列，它们是：[1, 2, 3], [1, 3, 2]；
再写以 2 开头的全排列，它们是：[2, 1, 3], [2, 3, 1]；
最后写以 3 开头的全排列，它们是：[3, 1, 2], [3, 2, 1]。

在枚举第一位的时候，有 3 种情况。
在枚举第二位的时候，前面已经出现过的数字就不能再被选取了；
在枚举第三位的时候，前面 2 个已经选择过的数字就不能再被选取了。

	vector<vector<int>> permute(vector<int>& nums) {
        if(nums.empty()) return {};
        // 存放最后结果
        vector<vector<int>> ans;
        // 存放某一个排列
        vector<int> temp;
        // 判断该数字是否被使用过
        vector<bool> used(nums.size(),false);
        // 进行递归求解
        dfs(ans,temp,used,nums);

        return ans;
    }

    void dfs(vector<vector<int>>& ans,vector<int>& temp,vector<bool>& used,
    const vector<int>& nums)
    {
        // 如果当前排列数组的长度等于输入数组的长度
        // 该排列已完成
        // 将该排列的加入结果中，返回
        if(temp.size()==nums.size())
        {
            ans.push_back(temp);
            return;
        }

        // 循环的进行枚举所有状态
        for(int i=0;i<nums.size();++i)
        {
            // 该数字已经选择过，跳过
            if(used.at(i)) continue;

            // 选择当前数字
            temp.push_back(nums.at(i));
            // 记录该数字已被选择
            used.at(i)=true;
            // 递归选择下一个数字
            dfs(ans,temp,used,nums);
            // 回溯，撤销当前选择
            used.at(i)=false;
            temp.pop_back();
        }
    }

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

 //1. 用map记录每个数字按键对应的所有字母
    map<char, string> M = {
        {'2', "abc"}, {'3', "def"}, {'4', "ghi"}, {'5', "jkl"}, {'6', "mno"},
        {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}
    };
    //2. 存储最终结果和临时结果的变量
    vector<string> ans;
    string current;

    //3. DFS函数，index是生成临时结果字串的下标，
    //每一个digits[index]数字对应临时结果current[index]的一位字母
    void DFS(int index, string digits) {
        //出口
        if(index == digits.size()) {
            ans.push_back(current);
            return;
        }
        //递归调用
        //对于当前输入的第index号数字(digits[index])，
        //枚举其对应的所有字母(M[digits[index]][i])
        for(int i = 0; i < M[digits[index]].size(); i++) {
            current.push_back(M[digits[index]][i]);     //临时结果压入一个字母
            DFS(index + 1, digits);         //以在当前位置压入该字母这一“情况”为前提，构造此“分支”的后续结果
            current.pop_back();             //状态还原，例如临时结果从 "ab" -> "a"，下一次循环尝试"ac" 
        }
    }

    vector<string> letterCombinations(string digits) {
        if(digits.size() == 0) {
            return ans;
        }
        DFS(0, digits);
        return ans;
    }

输入: nums = [1,2,3]
输出:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

如果当前子集构造完成，将它添加到输出集合中。

否则，从 first 到 n 遍历索引 i。

    将整数 nums[i] 添加到当前子集 curr。

    继续向子集中添加整数：backtrack(i + 1, curr)。

    从 curr 中删除 nums[i] 进行回溯。

class Solution {
private:
    vector<vector<int>> ret;
    vector<int> temp;
public:
   
    void DFS(vector<int>& nums,int pre,int level) {
        //退出条件：前面插入的是数组中最后一个元素
        if (pre == nums.back()) {
            temp.clear();
            return;
        }
            
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] <= pre)
                continue;
            temp.push_back(nums[i]);
            ret.push_back(temp);
            DFS(nums, nums[i],i+1);

            if (level)
                return;
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        ret.push_back({});
        if (nums.empty())
            return ret;
        DFS(nums, INT_MIN,0);
        return ret;
    }
};

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

board 和 word 中只包含大写和小写英文字母。
1 <= board.length <= 200
1 <= board[i].length <= 200
1 <= word.length <= 10^3

	int dir[4][4]={{-1,0},{1,0},{0,-1},{0,1}};
    
    bool exist(vector<vector<char>>& board, string word) {
        int m=board.size();
        int n=board[0].size();
        vector<vector<bool>> visited(m,vector<bool>(n));
        
        
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(dfs(i,j,0,board,word,visited))
                    return true;
            }
        }
        return false;
    }
    
    bool dfs(int x,int y,int index,vector<vector<char>>& board,string &word,vector<vector<bool>>& visited){
        if(index==word.size()-1){
            return word[index]==board[x][y];
        }
        
        if(word[index]==board[x][y]){
            visited[x][y]=true;
            for(int i=0;i<4;i++){
                int new_x=x+dir[i][0];
                int new_y=y+dir[i][1];
                
                if(new_x>=0&&new_x<board.size()&&new_y>=0&&new_y<board[0].size()&&!visited[new_x][new_y])
                    if(dfs(new_x,new_y,index+1,board,word,visited))
                        return true;
            }
            visited[x][y]=false;
            
        }
        return false;
    }