【算法】组合回溯专题

组合总数

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

class Solution {
    vector<vector<int>> res;
    vector<int>temp;
    

public:
    void dfs(vector<int>& candidates, int target, int idx){
        if(target<0){
            return;
        }
        if(target==0){
            res.push_back(temp);
            return;
        }
        for(int i =0; i<=idx;i++){
            temp.push_back(candidates[i]);
            dfs(candidates, target-candidates[i], i);
            temp.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        dfs(candidates, target, candidates.size()-1);
        return res;



        
    }
};

为了去重，需使用idx来约束每轮的终点
有了 4 3 2 后就不能出现 2 3 4

括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

class Solution {
    vector<string>res;
    string temp;
    
public:
    void dfs(int n, int left, int right){

        if(left < right){
            return;
        }
        if(left == n && right== n){
            res.push_back(temp);
            return;

        }
        if(left<n){
            temp.push_back('(');
            dfs(n, left+1, right);
            temp.pop_back();
        }
        if(right<n){
            temp.push_back(')');
            dfs(n, left, right+1);
            temp.pop_back();

        }
    }
    vector<string> generateParenthesis(int n) {
        dfs(n, 0, 0);
        return res;


    }
};

单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

class Solution {
public:
    bool dfs(vector<vector<char>>& board, string word, int k, int i, int j){
        if(k == word.size()){
            return true;
        }
        if(i<0 || j<0 || i>=board.size() || j>=board[0].size() || board[i][j]!=word[k]){
            return false;
        }
        char c = board[i][j];
        board[i][j] = '0';
        bool res = dfs(board, word, k+1, i-1, j) || dfs(board, word, k+1, i, j+1) || dfs(board, word, k+1, i, j-1) || dfs(board, word, k+1, i+1, j);
        board[i][j] = c ;
        return res;

    }
    bool exist(vector<vector<char>>& board, string word) {
        for(int i =0; i<board.size(); i++){
            for(int j =0; j<board[0].size(); j++){
                if(board[i][j]==word[0] && dfs(board, word, 0, i, j)){
                    return true;
                }
            }
        }
        return false;

    }
};