2020-10-23每天一刷

假设有两组括号，列出它所有组合的可能

思路：用递归的形式，列出所有可能的情况

#include "util.h"
using namespace std;
void mygenerate(string item, int n, vector<string>& result){
    if (item.size() == 2*n){//当字符串的长度为2n的时候结束递归
        result.push_back(item);
        return;
    }
    mygenerate(item+'(',n,result);//添加左括号继续递归
    mygenerate(item+')',n,result);//添加右括号继续递归

}
int main()
{
    vector<string> result;
    mygenerate("",2,result);
    for (auto it: result){
        cout<<it<<endl;
    }
}

力扣22

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

思路：和上一题一样递归之后，才能够列出所有可能的组合，在所有的合法的组合里面，左括号和右括号的数目是一样多的 当左括号的数目大于等于右括号的数目时，才能递归的加入右括号，否则就会不合法
代码如下：

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        helper("",n,n,result);
        return result;
    }
private:
    void helper(string item, int left, int right, vector<string>& result){
        if(left == 0 && right == 0){
            result.push_back(item);
            return;
        }
        if(left > 0){
            helper(item+'(',left-1,right,result);
        }
        if(left < right){
            helper(item+')',left,right-1,result);
        }
    }

};

力扣51

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

示例：

输入：4
输出：[
[".Q…", // 解法 1
“…Q”,
“Q…”,
“…Q.”],

["…Q.", // 解法 2
“Q…”,
“…Q”,
“.Q…”]
]
解释: 4 皇后问题存在两个不同的解法。

提示：

皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-queens
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
代码：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> result;
        vector<vector<int>> mark;
        vector<string> location;//?
        for (int i = 0; i < n; ++i) {
            mark.push_back((vector<int>()));
            for (int j = 0; j < n; ++j) {
                mark[i].push_back(0);
            }
            location.push_back("");
            location[i].append(n,'.');

        }
        generate(0,n,location,result,mark);
        return result;

    }
private:
    void put_down_the_queen(int x, int y,vector<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) {//每个方向延伸1到n-1
            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;
                }
            }
            }
        }
private:
    void generate(int k, int n, vector<string>& location,
                  vector<vector<string>>& result,
                  vector<vector<int>>& mark){
        if (k == n){
            result.push_back(location);
            return;
        }
        for (int i = 0; i < n; ++i) {
            if (mark[k][i] == 0){//
                vector<vector<int>> tem_mark = mark;
                location[k][i] = 'Q';
                put_down_the_queen(k,i,mark);
                generate(k+1,n,location,result,mark);
                mark = tem_mark;
                location[k][i] = '.';
            }
         
        }
    }

};

归并两个有序数组

思路：每次取两个数组中较小的那个数添加到result中去，然后移动指针。当只剩一个数组之后，就可以直接把剩下的数组直接加入到新的result中去。

#include "util.h"
using namespace std;
void merge_two(vector<int>& sub_vec1, vector<int>& sub_vec2,vector<int>& sub){
    int i = 0;
    int j = 0;
    while (i< sub_vec1.size() && j < sub_vec2.size()){
        if (sub_vec1[i] <=sub_vec2[j]){//这块是两个数组中开头的数在比较注意不要写错了
            sub.push_back(sub_vec1[i]);
            ++i;
        }
        else{
            sub.push_back(sub_vec2[j]);
            ++j;
        }
    }
    while (i < sub_vec1.size()){
        sub.push_back(sub_vec1[i]);
        ++i;
    }
    while (j < sub_vec2.size()){
        sub.push_back(sub_vec2[j]);
        ++j;
    }
}
int main()
{
  vector<int> nums1={2,5,8,20};
  vector<int> nums2={1,3,5,7,30,50};
  vector<int> num;
  merge_two(nums1,nums2,num);
  for (int i = 0; i < num.size(); ++i) {
      cout<<num[i]<<" ";
  }

}

归并排序的实现

利用分治的思想，分解，求解，合并（合并和求解放在一起完成）
代码如下：

#include "util.h"
using namespace std;
void merge_two(vector<int>& sub_vec1, vector<int>& sub_vec2,vector<int>& sub){
    int i = 0;
    int j = 0;
    while (i< sub_vec1.size() && j < sub_vec2.size()){
        if (sub_vec1[i] <=sub_vec2[j]){//这块是两个数组中开头的数在比较注意不要写错了
            sub.push_back(sub_vec1[i]);
            ++i;
        }
        else{
            sub.push_back(sub_vec2[j]);
            ++j;
        }
    }
    while (i < sub_vec1.size()){
        sub.push_back(sub_vec1[i]);
        ++i;
    }
    while (j < sub_vec2.size()){
        sub.push_back(sub_vec2[j]);
        ++j;
    }
}
void merge_sort(vector<int>&vec){
    if(vec.size() < 2){
        return;
    }
    int mid = vec.size()/2;
    vector<int> sub_vec1;
    vector<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);
    merge_sort(sub_vec2);
    vec.clear();
    merge_two(sub_vec1,sub_vec2,vec);
}
int main()
{
  vector<int> nums1={5,-7,9,8,1,4,-3,10,2,0};
  merge_sort(nums1);
  for (auto it : nums1){
      cout<<it<<" ";
  }
}