回溯算法:leetcode 216.组合总和III、17.电话号码的字母组合

leetcode 216.组合总和III

leetcode 17.电话号码的字母组合

leetcode 216.组合总和III

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字。说明:

  • 所有数字都是正整数。

  • 解集不能包含重复的组合。

同样本题无法使用暴力解法(for循环嵌套),因为for循环次数一旦过大,代码将无法书写。

本题的树型结构与leetcode 77.组合相似,同样是for循环进行横向遍历,递归进行纵向遍历

回溯三部曲:

  1. 确定递归函数的参数和返回值

定义两个全局变量path和result分别用来存放单次符合条件的结果和最后的结果集。

递归函数参数包括相加之和为k、结果中数的个数n;由于是组合问题,仍然引入一个参数startIndex用于记录每层for循环起始的位置,防止重复取;同时定义一个sum用于记录当前path中的元素之和。

vector<int> path;
vector<vector<int>> result;
void backtracking(int k, int n, int sum, int startIndex)
  1. 确定终止条件

如果path中的元素个数等于k并且sum和n的值相等,则说明找到了一个符合条件的结果。

if(path.size() == k){
    if(sum == n)
        result.push_back(path);
    return;
}
  1. 确定单层递归的逻辑

本题集合固定的就是9个数[1,...,9],所以for循环固定i<=9

for(int i = startIndex; i <= 9; i++){
    sum += i;
    path.push_back(i);
    backtracking(k, n, sum, i + 1);
    sum -= i;            // 回溯
    path.pop_back();     // 回溯
}

整体代码:

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(int n, int k, int sum, int startIndex){
        if(path.size() == k){
            if(sum == n)
                result.push_back(path);
            return;
        }
        for(int i = startIndex; i <= 9; i++){
            sum += i;
            path.push_back(i);
            backtracking(n, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }
};

剪枝:

所以加入:

if(sum > n)
    return;

即可。

总体代码如下:

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(int n, int k, int sum, int startIndex){
        if(sum > n){
            return;
        }
        if(path.size() == k){
            if(sum == n)
                result.push_back(path);
            return;
        }
        for(int i = startIndex; i <= 9; i++){
            sum += i;
            path.push_back(i);
            backtracking(n, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }
};

leetcode 17.电话号码的字母组合

给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。

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

理解本题后,要解决如下三个问题:

  1. 数字和字母如何映射

  1. 两个字母就两个for循环,三个字符我就三个for循环,以此类推,然后发现代码根本写不出来

  1. 输入1 * #按键等等异常情况

数字和字母映射

使用map的数据结构或者二维数组来实现数字和字母映射。

const string lettermap[10] = {
    "",       // 0
    "",       // 1
    "abc",    // 2
    "def",    // 3
    "ghi",    // 4
    "jkl",    // 5
    "mno",    // 6
    "pqrs",   // 7
    "tuv",    // 8
    "wxyz",   // 9 
}

回溯三部曲:

  1. 确定递归函数的参数和返回值

定义一个string型和vector<string>型的全局变量,用于存放单次符合条件的结果和结果集。

递归函数为void型,参数包括传入的字符串digits和index(输入digits的个数,用于记录遍历到哪一层了)。

string s;
vector<string> result;
void backtracking(const string& digits, int index)
  1. 确定终止条件

终止条件就是如果index 等于 输入的数字个数(digits.size)了(本来index就是用来遍历digits的)。

然后收集结果,结束本层递归。

代码如下:

if(index == digits.size())
    result.push_back(s);
    return;
  1. 确定单层递归的逻辑

首先要取index指向的数字,并找到对应的字符集(手机键盘的字符集)。

然后for循环来处理这个字符集,代码如下:

int digit = digits[index] - '0';        // 将index指向的数字转为int
string letters = letterMap[digit];      // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
    s.push_back(letters[i]);            // 处理
    backtracking(digits, index + 1);    // 递归,注意index+1,一下层要处理下一个数字了
    s.pop_back();                       // 回溯
}

整体代码:

class Solution {
private:
    vector<string> result;
    string s;
    const string letterMap[10] = {
        "",     // 0
        "",     // 1
        "abc",  // 2
        "def",  // 3
        "ghi",  // 4
        "jkl",  // 5
        "mno",  // 6
        "pqrs", // 7
        "tuv",  // 8
        "wxyz", // 9
    };
    
    void backtracking(const string& digits, int index){
        if(index == digits.size()){
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';
        string letters = letterMap[digit];
        for(int i = 0; i < letters.size(); i++){
            s.push_back(letters[i]);
            backtracking(digits, index + 1);
            s.pop_back();
        }
    }
public:
    vector<string> letterCombinations(string digits) {
        if(digits.size() == 0){
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

本题没有剪枝操作。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值