代码随想录-回溯算法(组合问题)|ACM模式

目录

前言:

77.组合

题目描述:

输入输出示例:

思路和想法:

216. 组合总和 III

题目描述:

输入输出示例:

思路和想法:

17. 电话号码的字母组合

题目描述:

输入输出描述:

思路和想法:

40. 组合总和 II

题目描述:

输入输出描述:

思路和想法:


前言:

这里对于组合问题,进行了深入的探讨(ACM模式):

  • 数组集合里元素不重复,元素只能取一次,组合不许重复
  • 引入总和统计
  • 引入map哈希
  • 引入去重的概念---(数组集合里元素有重复,元素只能取一次,但组合不许重复)

77.组合

题目描述:

给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

输入输出示例:

示例1:

输入:n = 4,k = 2 输出:[[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]

示例2:

输入:n = 1,k = 1 输出:[[1]]

提示:

  • 1 <= n <= 20
  • 1 <= k <= n

思路和想法:

回溯法的问题,都可以抽象为树形结构问题。

回溯法解决的是在集合中递归查找子集,集合的大小构成树的宽度,递归的深度构成树的深度。

这道题目属于组合问题的模板题。

#include 

using namespace std;
/*
* 作者:希希雾里
* 77.组合
* */

/*
* 这里我们能够比较清晰的,要使用回溯。
* */
vector> result;
vector path;
//这里对于回溯要传入的参数:元素数量,限定条件以及要开始遍历的元素
//这里能够比较清晰的知道n即为回溯的宽度,k即为回溯的深度。
void backtracing(int n, int k, int startIndex){
    /*终止条件*/
    if(path.size() == k){
        result.push_back(path);
        return;
    }
    /*处理节点 + 回溯撤销*/
    for (int i = startIndex; i <= n; ++i) {
        path.push_back(i);
        backtracing(n, k, i+1);
        path.pop_back();
    }
};

int main() {
    int n, k;
    cin>> n >> k;
    result.clear();
    path.clear();
    backtracing(n, k,1);

    //结果输出
    for (int i = 0; i < result.size(); ++i) {
        for (int j = 0; j < result[i].size(); ++j) {
            cout << result[i][j];
            if(j != result[i].size() - 1) cout << " ";
        }
        //注意最后输出不需要换行。
        if(i == result.size() - 1) return 0;
        cout << endl;
    }
    return 0;
}

/*  测试样例
4 2

1 1
*
* */

216. 组合总和 III

题目描述:

找出所有相加之和为 n 的 k 个数的组合,且满足下列条件:

  • 只使用数字1到9
  • 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次,组合可以以任何顺序返回。

输入输出示例:

示例1:

输入:k = 3, n = 7 输出:[[1,2,4]]

示例2:

输入:k = 3, n = 9 输出:[[1,2,6], [1,3,5], [2,3,4]]

示例3:

输入: k = 4, n = 1 输出:[]

提示:

  • 2 <= k <= 9
  • 1 <= n <= 60

思路和想法:

这道题目和上一道题基本一致,在原有基础上,还需要统计path里元素的总和,终止条件发生了改变, path.size() == k && sum == n 。

#include 

using namespace std;
/*
* 作者:希希雾里
* 216.组合总和III
* */
vector> result;
vector path;
int sum = 0;
//这里对于回溯要传入的参数,集合个数,目标总和以及要遍历的元素下标
void backtracing(int k, int n, int startIndex){
    /*终止条件*/
    if(path.size() == k && sum == n){
        result.push_back(path);
        return;
    }
    /*处理节点 + 回溯撤销*/
    for (int i = startIndex; i <= 9; ++i) {
        path.push_back(i);
        sum += i;
        backtracing(n, k, i + 1);
        sum -= path.back();
        path.pop_back();
    }
};

int main() {
    int n, k;
    cin>> n >> k;
    result.clear();
    path.clear();
    backtracing(k, n,1);

    //结果输出
    for (int i = 0; i < result.size(); ++i) {
        for (int j = 0; j < result[i].size(); ++j) {
            cout << result[i][j];
            if(j != result[i].size() - 1) cout << " ";
        }
        //注意最后输出不需要换行。
        if(i == result.size() - 1) return 0;
        cout << endl;
    }
    return 0;
}

17. 电话号码的字母组合

题目描述:

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

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

代码随想录-回溯算法(组合问题)|ACM模式_第1张图片

输入输出描述:

示例1:

输入:digits = "23" 输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例2:

输入:digits = "" 输出:[]

示例3:

输入:digits = "2" 输出:["a","b","c"]

提示:

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字

思路和想法:

这里首先构建数字和字符之间的映射,后续就是组合问题,采用回溯方法就可以解决了。

#include 

using namespace std;
/*
* 作者:希希雾里
* 17.电话号码的字母组合
* */
vector result;
string s;
//构建map,建立映射
const string map_letter[10] = {
"",
"",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz",
};

/*
* 函数:          backtracing()
* 输入参数:       digits:输入的字符串    index:字符串元素下标 
* */
void backtracing(const string & digits, int index){
    /*终止条件*/
    if(index == digits.length()){
        result.push_back(s);
        return;
    }
    int digit = digits[index] - '0';
    string letters = map_letter[digit];
    /*处理节点 + 回溯过程*/
    for (int i = 0; i < letters.length(); ++i) {
        s.push_back(letters[i]);
        backtracing(digits, index + 1);
        s.pop_back();
    }
};

int main() {
    result.clear();
    s.clear();
    //字符串输入
    string str;
    getline(cin,str);

    backtracing(str, 0);
    //结果输出
    for (int i = 0; i < result.size(); ++i) {
        //注意最后输出不需要换行。
        cout << result[i];
        if(i == result.size() - 1) return 0;
        cout << endl;
    }
    return 0;
}

/*  测试样例
23

2
*
* */

40. 组合总和 II

题目描述:

给定一个候选人编号的集合 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次

注意:解集不能包含重复的组合。

输入输出描述:

示例1:

输入:candidates = [10,1,2,7,6,1,5], target = 8 输出:[ [1,1,6], [1,2,5], [1,7], [2,6] ]

示例2:

输入:candidates = [2,5,2,1,2], target = 5, 输出:[ [1,2,2], [5] ]

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

思路和想法:

这道题目和之前不一样的地方在于,要取的数组里有数值相等的元素并且要求解集不能包含重复的组合。所以这道题目涉及到了去重。

一个组合里可以有重复的元素,即不需要树枝去重(纵向)。不能有重复的组合,即要进行树层去重(横向)。

树层去重和树枝去重,是根据树形结构,提出的去重概念。

那么转换到具体实现上,需要解决两个问题:

  • 如何实现去重?这里先对数组进行排序,将重复的元素紧挨在一起,之后遍历时判断与前面的元素是否相等即可。
  • 如何分辨树层去重和树枝去重?这里采用一个bool数组used,used[i - 1] == true,说明同一树枝candidates[i - 1]使用过,used[i - 1] == false,说明同一树层candidates[i - 1]使用过。
#include 

using namespace std;
/*
* 作者:希希雾里
* 40. 组合总和 II
* */
vector> result;
vector path;
int sum = 0;

/*
* 函数:          backtracing()
* 输入参数:       candidates:输入的数组    target: 目标数值     index:字符串元素下标       used:标志数组
* */
void backtracing(vector& candidates, int target, int index, vector& used){
    if(sum == target){
        result.push_back(path);
        return;
    }
    for(int i = index; i < candidates.size();++i){
        if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false){
            continue;
        }
        path.push_back(candidates[i]);
        sum += candidates[i];
        used[i] = true;
        backtracing(candidates, target, i + 1, used);
        used[i] = false;
        sum -= candidates[i];
        path.pop_back();
    }
};

int main() {
    result.clear();
    path.clear();

    vector candidates;
    int n;
    while(cin >> n){
        candidates.push_back(n);
        if(getchar() == '\n'){
            break;
        }
    }
    int target;
    cin >> target;
    vector used(candidates.size(),false);

    //默认升序排序
    sort(candidates.begin(),candidates.end());

    backtracing(candidates, target, 0, used);
    //结果输出
    for (int i = 0; i < result.size(); ++i) {
        for (int j = 0; j < result[i].size(); ++j) {
            cout << result[i][j];
            if(j != result[i].size() - 1) cout << " ";
        }
        //注意最后输出不需要换行。
        if(i == result.size() - 1) return 0;
        cout << endl;
    }
    return 0;
}

/*  测试样例
10 1 2 7 6 1 5
8

2 5 2 1 2
5
*
* */

你可能感兴趣的:(代码随想录感想,数据结构,算法,leetcode,c++)