回溯思想

模板

// 探索这个候选方案
// 当由它不能构建完整解法时返回false
// 当递归地调用LeadToSolution找到完整解法时
// 返回true
Boolean: LeadToSolution(Solution: test_solution)
    // 如果我们已经判断出这个局部解不能得到完整解，返回false
    If <test_solution 不能解决问题> Then Return false
    
    // 如果这是完整解，返回true
    If <test_solution 是完全解> Then Return true
    
    // 扩展局部解
    Loop <在所有可能test_solution的扩展上执行操作>
    	<扩展test_solution>
    	
    	// 递归地判断是否可以得到一个解
    	If(LeadToSolution(test_solution)) Then Return true
    	
    	// 这次扩展不能得出解，撤销本次更改
    	<取消扩展>
    End Loop
    
    // 如果我们执行到这一步，该局部解无法得出完整解
    Return false
End LeadToSolution

元素选择

solution1

#include <iostream>
#include <vector>

using namespace std;

void select_k_of_n_with_duplicates(int index, vector<int>& selections, vector<int>& items, vector<vector<int>>& results) {
	// 递归边界
	if (index == selections.size()) {
		vector<int> data;
		for (int i = 0; i < selections.size(); i++) {
			data.push_back(items[selections[i]]);
		}
		results.push_back(data);
	} else {
		// 扩展解
		int start = 0;
		
		// 允许重复选择
		if (index > 0) start = selections[index - 1] + 1;
		// 不允许重复选择
		// if (index > 0) starat = selections[index - 1] + 1;

		for (int i = start; i < items.size(); i++) {
			selections[index] = i;
			select_k_of_n_with_duplicates(index + 1, selections, items, results);
		}
	}
}

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    vector<vector<int>> results;
    vector<int> selections(3);

	select_k_of_n_with_duplicates(0, selections, nums, results);
	
	for (int i = 0; i < results.size(); i++) {
		for (int j = 0; j < results[i].size(); j++) {
			cout << results[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl << results.size() << endl;
    return 0;
}

solution2

#include <iostream>
#include <vector>
using namespace std;

void select(int len, int start, vector<int> nums, vector<int>& cur, vector<vector<int>>& results) {
    if (cur.size() == len) {
        results.push_back(cur);
        return;
    }
    for (int i = start; i < nums.size(); i++) {
        cur.push_back(nums[i]);
        select(len, i, nums, cur, results);
        // remove duplicates
        // select(len, i + 1, nums, cur, results);
        cur.pop_back();
    }
}

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    vector<vector<int>> results;
    vector<int> cur;
    select(2, 0, nums, cur, results);
    for (int i = 0; i < results.size(); i++) {
        for (int j = 0; j < results[i].size(); j++) {
            cout << results[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl << results.size();
    return 0;
}

幂集

#include <iostream>
#include <vector>
using namespace std;

void dfs(int len, int start, vector<int>& nums, vector<int>& cur, vector<vector<int>>& results) {
    if (len == cur.size()) {
        results.push_back(cur);
        return;
    }
    for (int i = start; i < nums.size(); i++) {
        // remove duplicates
        // if (i != start && nums[i] == nums[i - 1]) continue;
        
        cur.push_back(nums[i]);
        dfs(len, i + 1, nums, cur, results);
        // 回溯
        cur.pop_back();
    }
}

int main() {
    vector<int> nums = {1, 2, 2, 4, 5};
    vector<vector<int>> results;
    for (int i = 0; i < nums.size(); i++) {
        vector<int> cur;
        dfs(i, 0, nums, cur, results);
    }
    for (int i = 0; i < results.size(); i++) {
        for (int j = 0; j < results[i].size(); j++) {
            cout << results[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl << results.size();
    return 0;
}

元素排列

#include <iostream>
#include <vector>
using namespace std;

void permutations_with_duplicates(int len, vector<int>& nums, vector<int>& cur, vector<vector<int>>& results) {
    if (len == cur.size()) {
        results.push_back(cur);
        return;
    }
    for (int i = 0; i < nums.size(); i++) {
        cur.push_back(nums[i]);
        permutations_with_duplicates(len, nums, cur, results);
        cur.pop_back();
    }
}

void permutations_without_duplicates(int len, vector<int> nums, vector<int>& cur, vector<vector<int>>& results) {
    if (len == cur.size()) {
        results.push_back(cur);
        return;
    }
    for (int i = 0; i < nums.size(); i++) {
        bool used = false;
        for (int j = 0; j < cur.size(); j++) {
            if (cur[j] == nums[i]) used = true;
        }
        if (!used) {
            cur.push_back(nums[i]);
            permutations_without_duplicates(len, nums, cur, results);
            cur.pop_back();
        }
    }
}

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    vector<int> cur;
    vector<vector<int>> results;
    //permutations_with_duplicates(3, nums, cur, results);
    permutations_without_duplicates(3, nums, cur, results);
    for (int i = 0; i < results.size(); i++) {
        for (int j = 0; j < results[i].size(); j++) {
            cout << results[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl << results.size();
    return 0;
}