算法（十六）回溯法

leetcode

[hot] 17. 电话号码的字母组合

题目

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

题解

回溯法解决问题，示例代码如下所示：

class Solution {
public:
    void core(string digits, string combination, int index, unordered_map<char, string>& m) {
        if (index == digits.size()) {
            res.emplace_back(combination);
            return;
        }
        string letters = m[digits[index]];
        for (const auto& letter: letters) {
            combination.push_back(letter);
            core(digits, combination, index + 1, m);
            combination.pop_back();
        }
    }

    vector<string> letterCombinations(string digits) {
        string combination;
        if (digits.empty()) {
            return res;
        }
        unordered_map<char, string> m {
            {'2', "abc"},
            {'3', "def"},
            {'4', "ghi"},
            {'5', "jkl"},
            {'6', "mno"},
            {'7', "pqrs"},
            {'8', "tuv"},
            {'9', "wxyz"}        
        };
        core(digits, combination, 0, m);

        return res;
    }
private:
    vector<string> res;
};

复杂度

时间复杂度：$O(3^m+4^n)$，m代表有3个字母的数字个数，n代表有4个字母的数字个数
空间复杂度：$O(m+n)$

[hot] 207. 课程表

题目

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

题解

图的拓扑排序完成题解（leetcode题解），示例代码如下所示：

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        visited = vector<int>(numCourses);
        for (const auto& elem: prerequisites) {
            edges[elem[1]].emplace_back(elem[0]);
        }
        for (int i = 0; i < numCourses; ++i) {
            if (!visited[i]) {
                dfs(i);
            }
        }

        return valid;

    }

    void dfs(int u) {
        visited[u] = 1;
        for (auto v: edges[u]) {
            if (visited[v] == 1) {
                valid = false;
                return;
            } else if (visited[v] == 0) {
                dfs(v);
                if (!valid) {
                    return;
                }
            }
        }
        visited[u] = 2;
    }
private:
    bool valid = true;
    vector<vector<int>> edges;
    vector<int> visited;
};

复杂度

时间复杂度：$O(n+m)$，n为节点数，m为先修课程数。
空间复杂度：$O(n+m)$，visited和edgs的辅助空间大小。

题解2 BFS

队列正向解决问题，示例代码如下所示：

class Solution {
private:
    vector<vector<int>> edges;
    vector<int> indeg;

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        indeg.resize(numCourses);
        for (const auto& info: prerequisites) {
            edges[info[1]].push_back(info[0]);
            ++indeg[info[0]];
        }

        queue<int> q;
        for (int i = 0; i < numCourses; ++i) {
            if (indeg[i] == 0) {
                q.push(i);
            }
        }

        int visited = 0;
        while (!q.empty()) {
            ++visited;
            int u = q.front();
            q.pop();
            for (int v: edges[u]) {
                --indeg[v];
                if (indeg[v] == 0) {
                    q.push(v);
                }
            }
        }

        return visited == numCourses;
    }
};

时间和空间复杂度与题解1相同

[hot] 301. 删除无效的括号

题目

给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。

返回所有可能的结果。答案可以按 任意顺序 返回。

示例 1：
输入：s = "()())()"
输出：["(())()","()()()"]

示例 2：
输入：s = "(a)())()"
输出：["(a())()","(a)()()"]

示例 3：
输入：s = ")("
输出：[""]

题解

思路如 这里 ， 示例代码如下所示：

class Solution {
public:
    vector<string> res;
    vector<string> removeInvalidParentheses(string s) {
        int l_r = 0;
        int r_r = 0;
        for (auto c : s) {
            if (c == '(') {
                ++l_r;
            } else if (c == ')') {
                if (l_r == 0) {
                    ++r_r;
                } else {
                    --l_r;
                }
            }
        }

        helper(s, l_r, r_r, 0);
        return res;
    }

    void helper(string str, int l_r, int r_r, int start) {
        if (l_r == 0 && r_r == 0 && is_valid(str)) {
            res.emplace_back(str);
            return;
        }
        for (int i = start; i < str.size(); ++i) {
            if (i > start && str[i] == str[i - 1]) {
                continue;
            }
            if (l_r + r_r > str.size() - i) {
                return;
            }
            if (l_r > 0 && str[i] == '(') {
                helper(str.substr(0, i) + str.substr(i + 1), l_r - 1, r_r, i);
            }
            if (r_r > 0 && str[i] == ')') {
                helper(str.substr(0, i) + str.substr(i + 1), l_r, r_r - 1, i);
            }
        }
    }

    bool is_valid(string& s) {
        int cnt = 0;
        for (auto& c: s) {
            if (c == '(') {
                ++cnt;
            } else if (c == ')') {
                --cnt;
                if (cnt < 0) {
                    return false;
                }
            }
        }

        return cnt == 0;
    }
};

复杂度

时间复杂度：$O(n\ast 2^n)$，回溯时间复杂度
空间复杂度：$O(n^2)$，递归遍历次数