教你做回溯题(Leetcode电话号码的字母组合、括号生成和单词搜索)-第四期

前三期指路：

第一期

第二期

第三期

这次应该是回溯最后一期了，前几次的题目比较常规，基本是什么子集或者排列什么的书面语言，这期就总结一些比较偏向应用类的题目，当然其实本质还是那一套。

例题

电话号码的字母组合

给定一个仅包含数字2-9的字符串，返回所有能表示的字母组合，其中这个数字与字母的映射关系如下（就是我们手机键盘）：

 定义一个映射向量方便操作

vector<string> mapping{"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};

例如数字2的映射的字母就是mapping[2-2][i]，i为字符串的索引。

①选择实例“23”画图

②确定结束条件

 由于是求映射，最后得到的映射结果长度等于给的字符长度是就结束

//结束条件
if(path.length()==digits.length()){
    res.push_back(path);
    return;
}

③确定选择列表，选择列表就是当前节点要映射的数字映射的字符串。

for(int i=0;i<mapping[digits[index]-'0'-2].length();i++)

④剪枝，这题画图发现没有重复的，无需剪枝

⑤⑥⑦选择、递归、撤销

由于每次递归，往深处递归，那么要映射的字符是下一个，所以index+1

//选择
path.push_back(mapping[digits[index]-'0'-2][i]);
//递归
dfs(digits,path,res,index+1);
//撤销
path.pop_back();

完整代码：

class Solution {
public:
    vector<string> mapping{"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    vector<string> letterCombinations(string digits) {
        string path;
        vector<string> res;
        if(digits==""){
            return res;
        }
        dfs(digits,path,res,0);
        return res;
    }

    void dfs(string digits, string& path, vector<string>& res, int index){
        //结束条件
        if(path.length()==digits.length()){
            res.push_back(path);
            return;
        }

        for(int i=0;i<mapping[digits[index]-'0'-2].length();i++){
            //选择
            path.push_back(mapping[digits[index]-'0'-2][i]);
            //递归
            dfs(digits,path,res,index+1);
            //撤销
            path.pop_back();
        }

    }
};

括号生成

给定一个数字n表示生成的括号对数，生成所有可能并有效的括号组合。

①选择实例n=2画图

 ②确定结束条件

当选择的左括号和右括号的个数等于n时，代表完成了

//结束条件
if(left_count==n && right_count==n){
    res.push_back(path);
    return;
}

③确定选择列表，选择列表就是不是那么有规律，给当前节点已选择的有关，比如若当前节点左括号未选完则可以选择左括号，右括号数量小于左括号则可以选择右括号，也就是说其实这题选择列表没必要用for循环，用两个条件即可

//有左括号选左括号
if(left_count<n)

//右括号小于左括号数量
if(right_count<n && right_count<left_count)

④剪枝，无需剪枝

⑤⑥⑦选择、递归、撤销

//选择左括号
++left_count;
path.push_back('(');
//递归
dfs(n,res,path,left_count,right_count);
//撤销
--left_count;
path.pop_back();

//选择右括号
++right_count;
path.push_back(')');
//递归
dfs(n,res,path,left_count,right_count);
//撤销
--right_count;
path.pop_back();

完整代码：

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        string path;
        //左括号数，右括号数
        int left_count,right_count;
        dfs(n,res,path,left_count,right_count);
        return res;
    }

    void dfs(int n, vector<string>& res, string& path, int left_count, int right_count){
        //结束条件
        if(left_count==n && right_count==n){
            res.push_back(path);
            return;
        }
        //有左括号选左括号
        if(left_count<n){
            //选择
            ++left_count;
            path.push_back('(');
            //递归
            dfs(n,res,path,left_count,right_count);
            //撤销
            --left_count;
            path.pop_back();
        }
        //右括号小于左括号数量
        if(right_count<n && right_count<left_count){
            //选择
            ++right_count;
            path.push_back(')');
            //递归
            dfs(n,res,path,left_count,right_count);
            //撤销
            --right_count;
            path.pop_back();
        }
    }
};

单词搜索

给定一个二维数组和一个字符串单词，判断字符串是否存在于二维网格中。单词必须按照字母顺序，通过（水平或垂直）相邻的单元格内的字母构成。

①选择实例画图，由于这题不好画成树。反而这题很像DFS刷题总结中的题目。

因为同样是二维格子，同样是上下左右四周作为邻接结点。

②确定结束条件

得到的结果是等于单词即可

//结束条件
if(path==word){
    flag=true;
    return;
}

③确定选择列表，选择列表明显是上下左右四周，但前提是不越界且在当前深度遍历中未被访问过。direction是方便取四周，可以看dfs总结那一期。

for(int i=0;i<4;i++){
    x=l+direction[i];
    y=r+direction[i+1];
    if(x>=0 && x<board.size() && y>=0 && y<board[0].size() && !visited[x][y]){

    }
}

④剪枝，不等于当前单词字符的剪枝，也就是只选择符合的

if(board[x][y]!=word[start]){
    continue;
}

不符合跳过可以写成符合才选择

if(board[x][y]==word[start]){
    //选择
}

⑤⑥⑦选择、递归、撤销

由于每次匹配了单词的一个字符，下次选择递归就是匹配下一个字符，所以是start+1。

//选择
path.push_back(word[start]);
visited[x][y]=true;
//递归
dfs(board,word,path,flag,x,y,visited,start+1);
//撤销
path.pop_back();
visited[x][y]=false;

完整代码：

class Solution {
public:
    vector<int> direction{-1,0,1,0,-1};
    bool exist(vector<vector<char>>& board, string word) {
        string path;
        bool flag=false;
        int m=board.size(),n=board[0].size();
        vector<vector<bool>> visited(m,vector<bool>(n,false));
        for(int i=0;i<m;i++){
            if(flag) break;
            for(int j=0;j<n;j++){
                if(flag) break;
                if(board[i][j]==word[0]){     
                    //选择          
                    path.push_back(word[0]);
                    visited[i][j]=true;
                    dfs(board,word,path,flag,i,j,visited,1);
                    //撤销
                    path.pop_back();
                    visited[i][j]=false;
                }
            }
        }
        return flag;
    }

//这个flag的&别忘了加
    void dfs(vector<vector<char>>& board, string word, string& path, bool& flag,int l,int r,vector<vector<bool>>& visited,int start){
        //结束条件
        if(path==word){
            flag=true;
            return;
        }
        int x,y;
        for(int i=0;i<4;i++){
            x=l+direction[i];
            y=r+direction[i+1];
            if(x>=0 && x<board.size() && y>=0 && y<board[0].size() && !visited[x][y]){
                if(board[x][y]==word[start]){
                    //选择
                    path.push_back(word[start]);
                    visited[x][y]=true;
                    //递归
                    dfs(board,word,path,flag,x,y,visited,start+1);
                    //撤销
                    path.pop_back();
                    visited[x][y]=false;
                }
            }
        }

    }
};