DAY25!||电话号码的字母组合，组合总和

题目：17. 电话号码的字母组合

链接: leetcode题目链接

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1:
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

示例 2:
输入：digits = “”
输出：[]

示例3:
输入：digits = “2”
输出：[“a”,“b”,“c”]

提示：
1).0 <= digits.length <= 4
2).digits[i] 是范围 [‘2’, ‘9’] 的一个数字。

实现算法:回溯算法

两个集合的组合

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

p.s.
1.index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
2.每一个数字代表的是不同集合，也就是求不同集合之间的组合,注意for循环范围。

自我实现

先用字符串数组表把每个按键数字对应的字母列出来，然后index选取输入的第index位数字时，首先要转化成这个数字对应的字母字符串。因为输入的数字是string类型的，所以“ -‘0’ ”转化为真正的数字，再从数组表中找到对应的字母串。

class Solution {
public:
    vector<string> result;
    string path;
    string lettermap[10]={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    
    void backtracking(int index,string digits){
        if(path.size()==digits.size()){
            result.push_back(path);
            return;
        }
        int digit=digits[index]-'0';
        string letter=lettermap[digit];
        for(int i=0;i<letter.size();i++){
            path+=letter[i];
            backtracking(index+1,digits);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return result;
        backtracking(0,digits);
        return result;
    }

};

p.s.
输入为空的话，如果不判断，就会输出空的引号。。。

题目：39. 组合总和

链接: leetcode题目链接

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1:
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2:
输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例3:
输入: candidates = [2], target = 1
输出: []

提示：
1).1 <= candidates.length <= 30
2).2 <= candidates[i] <= 40
3).candidates 的所有元素 互不相同
4).1 <= target <= 40

实现算法:回溯算法

如果是一个集合来求组合的话，就需要startIndex
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i); // 不用i+1了，表示可以重复读取当前的数
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

p.s.
单层for循环依然是从startIndex开始，搜索candidates集合，因为本题元素可重复选取。

自我实现

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    int sum=0;
    void tracebacking(int target,int starindex,vector<int>& candidates){
        if(sum>target) return;
        if(sum==target){
            result.push_back(path);
            return;
        }
        for(int i=starindex;i<candidates.size();i++){
            path.push_back(candidates[i]);
            sum+=candidates[i];
            tracebacking(target,i,candidates);
            path.pop_back();
            sum-=candidates[i];
        }
    }
    
    
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        tracebacking(target,0,candidates);
        return result;
    }

};

p.s.
基本上大差不差，easy AC !!

做题心得

还好，比二叉树舒服一点，等回溯刷完再去看树，应该会更好吧