//将链表中的节点push进vector
#include <stdio.h>
#include <vector>
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL) {}
};
void add_to_vector(ListNode* head, std::vector<int>& vec) {
if (head == NULL) return;
vec.push_back(head->val);
add_to_vector(head->next, vec);
}
int main() {
ListNode a(1);
ListNode b(2);
ListNode c(3);
ListNode d(4);
ListNode e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
std::vector<int> vec;
add_to_vector(&a, vec);
for (int i = 0; i < vec.size(); i++) {
printf("[%d]", vec[i]);
}
printf("\n");
return 0;
}
例一:LeetCode78
//已知一数组(其中无重复元素),求这组数组可以组成的所有子集
//不能有重复子集。
#include <stdio.h>
#include <vector>
// int main() {//非递归
// std::vector<int> nums;
// nums.push_back(1);
// nums.push_back(2);
// nums.push_back(3);
// std::vector<int> item;
// std::vector<std::vector<int>> result;
// for (int i = 0; i < nums.size(); i++) {
// item.push_back(nums[i]);
// result.push_back(item);
// }
// for (int i = 0; i < nums.size(); i++) {
// for (int j = 0; j < result[i].size(); j++) {
// printf("[%d]", result[i][j]);
// }
// printf("\n");
// }
// return 0;
// }
// void generate(int i, std::vector<int>& nums, std::vector<int>& item, std::vector<std::vector<int>>& result) {
// if (i >= nums.size())return;
// item.push_back(nums[i]);
// result.push_back(item);
// generate(i + 1, nums, item, result);
// }
// int main() {//递归
// std::vector<int> nums;
// nums.push_back(1);
// nums.push_back(2);
// nums.push_back(3);
// std::vector<int> item;
// std::vector<std::vector<int>> result;
// generate(0, nums, item, result);
// for (int i = 0; i < result.size(); i++) {
// for (int j = 0; j < result[i].size(); j++) {
// printf("[%d]", result[i][j]);
// }
// printf("\n");
// }
// return 0;
// }
class Solution {
public:
std::vector<std::vector<int>> subsets(std::vector<int>& nums) {
std::vector<std::vector<int>> result;
std::vector<int> item;
result.push_back(item);
generate(0, nums, item, result);
return result;
}
private:
void generate(int i, std::vector<int>& nums, std::vector<int>& item, std::vector<std::vector<int>>& result) {
if (i >= nums.size()) return;
item.push_back(nums[i]);
result.push_back(item);
generate(i + 1, nums, item, result);
item.pop_back();
generate(i + 1, nums, item, result);
}
};
class Solution {
public:
std::vector<std::vector<int>> subsets(std::vector<int>& nums) {
std::vector<std::vector<int>> result;
int all_set = 1 << nums.size();
for (int i = 0; i < all_set; i++) {
std::vector<int> item;
for (int j = 0; j < nums.size(); j++) {
if (i & (1 << j)) {
item.push_back(nums[j]);
}
}
result.push_back(item);
}
return result;
}
};
int main() {
std::vector<int> nums;
nums.push_back(1);
nums.push_back(2);
nums.push_back(3);
std::vector<std::vector<int>> result;
Solution solve;
result = solve.subsets(nums);
for (int i = 0; i < result.size(); i++) {
if (result[i].size() == 0) {
printf("[]");
}
for (int j = 0; j < result[i].size(); j++) {
printf("[%d]", result[i][j]);
}
printf("\n");
}
return 0;
}
例二:LeetCode90
//已知一组数(有重复元素),求这组数可以组成的所有子集
//结果中无重复子集
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <set>
class Solution {
public:
std::vector<std::vector<int>> subsetsWithDup(std::vector<int>& nums) {
std::vector<std::vector<int>> result;
std::vector<int> item;
std::set<std::vector<int>> res_set;
std::sort(nums.begin(), nums.end());
result.push_back(item);
generate(0, nums, result, item, res_set);
return result;
}
private:
void generate(int i, std::vector<int>& nums, std::vector<std::vector<int>>& result, std::vector < int>& item, std::set<std::vector<int>>& res_set) {
if (i >= nums.size()) {
return;
}
item.push_back(nums[i]);
if (res_set.find(item) == res_set.end()) {
result.push_back(item);
res_set.insert(item);
}
generate(i + 1, nums, result, item, res_set);
item.pop_back();
generate(i + 1, nums, result, item, res_set);
}
};
int main() {
std::vector<int> nums;
nums.push_back(2);
nums.push_back(1);
nums.push_back(2);
nums.push_back(2);
std::vector<std::vector<int>> result;
Solution solve;
result = solve.subsetsWithDup(nums);
for (int i = 0; i < result.size(); i++) {
if (result[i].size() == 0) {
printf("[]");
}
for (int j = 0; j < result[i].size(); j++) {
printf("[%d]", result[i][j]);
}
printf("\n");
}
return 0;
}
例三:LeetCode40
/**已知一组数(其中有重复的元素),求这组数可以组成的所有子集中各个元素
和为整数target的子集,结果中无重复子集。
*/
#include <stdio.h>
#include <vector>
#include <set>
#include <algorithm>
class Solution {
public:
std::vector<std::vector<int>> combinationSum2(std::vector<int>& candidates, int target) {
std::vector<std::vector<int>> result;
std::vector<int> item;
std::set < std::vector<int>> res_set;
std::sort(candidates.begin(), candidates.end());
generate(0, candidates, result, item, res_set, 0, target);
return result;
}
private:
void generate(int i, std::vector<int>& nums, std::vector<std::vector<int>>& result, std::vector<int>& item, std::set<std::vector<int>>& res_set, int sum, int target) {
if (i >= nums.size() || sum > target) return;
sum += nums[i];
item.push_back(nums[i]);
if (sum == target && res_set.find(item) == res_set.end()) {
result.push_back(item);
res_set.insert(item);
}
generate(i + 1, nums, result, item, res_set, sum, target);
sum -= nums[i];
item.pop_back();
generate(i + 1, nums, result, item, res_set, sum, target);
}
};
int main() {
std::vector<int> nums;
nums.push_back(10);
nums.push_back(1);
nums.push_back(2);
nums.push_back(7);
nums.push_back(6);
nums.push_back(1);
nums.push_back(5);
std::vector<std::vector<int>> result;
Solution solve;
result = solve.combinationSum2(nums, 8);
for (int i = 0; i < result.size(); i++) {
if (result[i].size() == 0) {
printf("[]");
}
for (int j = 0; j < result[i].size(); j++) {
printf("[%d]", result[i][j]);
}
printf("\n");
}
return 0;
}
例四:LeetCode22
//已知有n组括号,开发一个程序,生成这n组括号的所有的合法的组合的可能。
#include <stdio.h>
#include <vector>
#include <string>
// void generate(std::string item, int n, std::vector<std::string> &result){
// if(item.size() == 2*n){
// result.push_back(item);
// return;
// }
// generate(item+'(', n, result);
// generate(item+')', n, result);
// }
// int main(){
// std::vector<std::string> result;
// generate("", 2, result);
// for(int i=0; i<result.size(); i++){
// printf("'%s'\n", result[i].c_str());
// }
// result;
// }
class Solution {
public:
std::vector<std::string> generateParenthesis(int n) {
std::vector<std::string> result;
generate("", n, n, result);
return result;
}
private:
void generate(std::string item, int left, int right, std::vector<std::string>& result) {
if (left == 0 && right == 0) {
result.push_back(item);
return;
}
if (left > 0) {
generate(item + '(', left - 1, right, result);
}
if (left < right) {
generate(item + ')', left, right - 1, result);
}
}
};
int main() {
Solution solve;
std::vector<std::string> result = solve.generateParenthesis(3);
for (int i = 0; i < result.size(); i++) {
printf("%s\n", result[i].c_str());
}
return 0;
}
例五:LeetCode51
//N皇后问题
#include <stdio.h>
#include <vector>
#include <string>
class Solution {
public:
std::vector<std::vector<std::string>> solveNQueens(int n) {
std::vector<std::vector<std::string>> result;
std::vector<std::vector<int>> mark;
std::vector<std::string> location;
for (int i = 0; i < n; i++) {
mark.push_back((std::vector<int>()));//先push进空的vector,为后面访问二级数组做铺垫
for (int j = 0; j < n; j++) {
mark[i].push_back(0);//初始化mark为0
}
location.push_back("");//push进空字符串
location[i].append(n, '.');//将字符串初始为n个.
}
generate(0, n, location, result, mark);
return result;
}
private:
void put_down_the_queen(int x, int y, std::vector<std::vector<int>>& mark) {
static const int dx[] = { -1, 1, 0, 0, -1, -1, 1, 1 };//方向数组
static const int dy[] = { 0, 0, -1, 1, -1, 1, -1, 1 };
mark[x][y] = 1;
for (int i = 1; i < mark.size(); i++) {
for (int j = 0; j < 8; j++) {
int new_x = x + i * dx[j];
int new_y = y + i * dy[j];
if (new_x >= 0 && new_x < mark.size() && new_y >= 0 && new_y < mark.size()) {
mark[new_x][new_y] = 1;
}
}
}
}
void generate(int k, int n, std::vector<std::string>& location, std::vector<std::vector<std::string>>& result, std::vector<std::vector<int>>& mark) {
if (k == n) {
result.push_back(location);
return;
}
for (int i = 0; i < n; i++) {
if (mark[k][i] == 0) {
std::vector<std::vector<int>> tmp_mark = mark;
location[k][i] = 'Q';
put_down_the_queen(k, i, mark);
generate(k + 1, n, location, result, mark);
mark = tmp_mark;
location[k][i] = '.';
}
}
}
};
int main() {
std::vector<std::vector<std::string>> result;
Solution solve;
result = solve.solveNQueens(4);
for (int i = 0; i < result.size(); i++) {
printf("i = %d\n", i);
for (int j = 0; j < result[i].size(); j++) {
printf("%s\n", result[i][j].c_str());
}
}
return 0;
}
例六:LeetCode315
//已知数组nums,求新数组count,count[i]代表了在nums[i]右侧且比nums[i]小的个数
#include <stdlib.h>
#include <vector>
#include <assert.h>
#include <algorithm>
#include <time.h>
// int main() {
// std::vector<int> vec1;
// std::vector<int> vec2;
// srand(time(NULL));
// for (int i = 0; i < 10000; i++) {
// int num = (rand() * rand()) % 100003;
// vec1.push_back(num);
// vec2.push_back(num);
// }
// merge_sort(vec1);
// std::sort(vec2.begin(), vec2.end());
// assert(vec1.size() == vec2.size());//断言:测试是否符合条件,否则终止程序
// for (int i = 0; i < vec1.size(); i++) {
// assert(vec1[i] == vec2[i]);
// }
// return 0;
// }
class Solution {
public:
std::vector<int> countSmaller(std::vector<int>& nums) {
std::vector<std::pair<int, int>> vec;
std::vector<int> count;
for (int i = 0; i < nums.size(); i++) {
vec.push_back(std::make_pair(nums[i], i));
count.push_back(0);
}
merge_sort(vec, count);
return count;
}
private:
//归并两个已排序数组
void merge_sort_two_vec(std::vector<std::pair<int, int>>& sub_vec1, std::vector<std::pair<int, int>>& sub_vec2,
std::vector<std::pair<int, int>>& vec, std::vector<int>& count) {
int i = 0;
int j = 0;
while (i < sub_vec1.size() && j < sub_vec2.size()) {
if (sub_vec1[i].first <= sub_vec2[j].first) {
count[sub_vec1[i].second] += j;
vec.push_back(sub_vec1[i]);
i++;
}
else {
vec.push_back(sub_vec2[j]);
j++;
}
}
for (; i < sub_vec1.size(); i++) {
count[sub_vec1[i].second] += j;
vec.push_back(sub_vec1[i]);
}
for (; j < sub_vec2.size(); j++) {
vec.push_back(sub_vec2[j]);
}
}
void merge_sort(std::vector<std::pair<int, int>>& vec, std::vector<int>& count) {//归并排序
if (vec.size() < 2) {
return;
}
int mid = vec.size() / 2;
std::vector<std::pair<int, int>> sub_vec1;
std::vector<std::pair<int, int>> sub_vec2;
for (int i = 0; i < mid; i++) {
sub_vec1.push_back(vec[i]);
}
for (int i = mid; i < vec.size(); i++) {
sub_vec2.push_back(vec[i]);
}
merge_sort(sub_vec1, count);
merge_sort(sub_vec2, count);
vec.clear();
merge_sort_two_vec(sub_vec1, sub_vec2, vec, count);
}
};
int main() {
int test[] = { 5, -7, 9, 1, 3, 5, -2, 1 };
std::vector<int> nums;
for (int i = 0; i < 8; i++) {
nums.push_back(test[i]);
}
Solution solve;
std::vector<int> result = solve.countSmaller(nums);
for (int i = 0; i < result.size(); i++) {
printf("[%d]", result[i]);
}
printf("\n");
return 0;
}