C++算法---递归、回溯、分治

求子集（回溯法）

#include <vector>
#include <iostream>

using namespace std;

void generate(int i,vector<int> &nums,vector<int> &item,vector<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);
}


int main()
{
    
    vector<vector<int> > result;
    vector<int> item;
    vector<int> nums;
    
    nums.push_back(1);
    nums.push_back(2);
    nums.push_back(3);
    
    result.push_back(item);
    generate(0,nums,item,result);
    
    vector<vector<int > >::iterator iter;
    for (iter = result.begin(); iter != result.end() ; ++iter) {
        for (int i = 0; i < (*iter).size(); ++i) {
            cout << (*iter)[i] << " " ;
        }
        cout << endl;
    }
    
    return 0;
}

求子集（位运算法）

#include <vector>
#include <iostream>

using namespace std;

class Solution{
public:
    vector<vector<int> > subsets(vector<int> &nums){
        vector<vector<int> >result;
        int sub_set = 1 << nums.size();
        
        for (int i=0; i<sub_set; i++){
            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()
{
    vector<int> nums;
    vector<vector<int> > result;
    Solution solve;
    
    nums.push_back(1);
    nums.push_back(2);
    nums.push_back(3);
    
    result = solve.subsets(nums);
    for (int i=0; i<result.size(); i++){
        if (result[i].size() == 0){
            cout<<"\n";
        }
        
        for (int j=0; j<result[i].size(); j++){
            cout<<result[i][j]<<" ";
        }
        cout<<"\n";
    }
    
    return 0;
}

求子集（有重复元素,结果无重复子集）

#include <vector>
#include <iostream>
#include <set>
#include <algorithm>

using namespace std;

class Soluction{
public:
    vector<vector<int> > SubsetsWithDup(vector<int> &nums){
        vector<int> item;
        vector<vector<int> > result;
        set<vector<int> > res_set;
        
        sort(nums.begin(),nums.end());

        result.push_back(item);
        generate(0,nums,item,res_set,result);
        return result;
    }

private:
    void generate(int i,vector<int> &nums,
    vector<int> &item,
    set<vector<int> > &res_set,
    vector<vector<int> > &result){
        
        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,item,res_set,result);
        item.pop_back();
        generate(i+1,nums,item,res_set,result);
    }
};

int main()
{
    vector<int> nums;
    vector<vector<int> > result;  
    Soluction solve;
    
    nums.push_back(2);
    nums.push_back(1);
    nums.push_back(2);
    nums.push_back(2);
    
    result = solve.SubsetsWithDup(nums);
    
    for (int i=0; i<result.size(); i++){
        if (result[i].size() == 0){
            cout<<"\n";
        }
        for (int j=0; j<result[i].size(); j++){
            cout << result[i][j]<<" ";
        }
        cout << "\n";
    }
    return 0;
}

组合数之和

#include <vector>
#include <iostream>
#include <set>
#include <algorithm>

using namespace std;

class Soluction{
public:
    vector<vector<int> > combinataion(vector<int> &nums,int target){
        vector<int> item;
        vector<vector<int> > result;
        set<vector<int> > res_set;
        
        sort(nums.begin(),nums.end());

        result.push_back(item);
        generate(0,nums,item,res_set,result,0,target);
        return result;
    }

private:
    void generate(int i,vector<int> &nums,
    vector<int> &item,
    set<vector<int> > &res_set,
    vector<vector<int> > &result,
    int sum,int target){
        
        if (i>=nums.size() || sum > target){
            return;
        }
        
        item.push_back(nums[i]);
        sum += nums[i];
        
        if (sum == target && res_set.find(item) == res_set.end()){
            result.push_back(item);
            res_set.insert(item);
        }
        
        generate(i+1,nums,item,res_set,result,sum,target);
        item.pop_back();
        sum -= nums[i];
        generate(i+1,nums,item,res_set,result,sum,target);
    }
};

int main()
{
    vector<int> nums;
    vector<vector<int> > result;  
    Soluction solve;
    
    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);
 
 
    result = solve.combinataion(nums,8);
    
    for (int i=0; i<result.size(); i++){
        if (result[i].size() == 0){
            continue;
        }
        for (int j=0; j<result[i].size(); j++){
            cout << result[i][j]<<" ";
        }
        cout << "\n";
    }
    return 0;
}

生成括号

#include <vector>
#include <iostream>
#include <set>
#include <algorithm>

using namespace std;

class Soluction{
public:
    vector<string> generatebracket(int nums){
        vector<string> result;
        generate("",nums,nums,result);
        return result;
    }
private:
    void generate(string item,int left,int right,vector<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()
{
    vector<int> nums;
    vector<string> result;  
    Soluction solve;
    
    result = solve.generatebracket(3);
    
    for (int i=0; i<result.size(); i++){
        cout << result[i].c_str()<<endl;
    }
    return 0;
}

N皇后

#include <vector>
#include <iostream>
#include <set>
#include <algorithm>

using namespace std;

class N_QUEUE
{
public:
    vector<vector<string> > Solution_NQUEUE(int n)
    {
        vector<vector<int> > mark;
        vector<string> location;
        vector<vector<string> > result;
        
        /*初始化location和mark*/
        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,mark,location,result);
        return result;
    }
    
private:
    void put_down_the_queue(int x,int y,vector<vector<int> > &mark)
    {
        static const int dx[]={-1,-1, 0,1, 1, 1, 0,-1};
        static const int dy[]={ 0, 1, 1,1, 0,-1,-1,-1};
        mark[x][y] = 1;
        
        for (int i=0; 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;
                }
            }
        }
        return;
    }
    
    void generate(int k,int n,vector<vector<int> > &mark,
    vector<string> &location,vector<vector<string> > &result)
    {
        if (k == n){
            result.push_back(location);
            return;
        }
        
        for (int i=0; i<n ;i++){
            if (mark[k][i] == 0){
                vector<vector<int> > tmp_mark=mark;
                location[k][i] = 'Q';
                put_down_the_queue(k,i,mark);
                
                generate(k+1,n,mark,location,result);
                
                location[k][i] = '.';
                mark = tmp_mark;
            }
        }
    }
};

int main()
{
    class N_QUEUE solve;
    vector<vector<string> > result;

    result=solve.Solution_NQUEUE(4);
    for (int i=0; i<result.size(); i++){
        cout << "i="<<i+1<<endl;
        for (int j=0; j<result[i].size(); j++){
            cout << result[i][j].c_str() << endl;
        }
    }
    
    return 0;
}

逆序数

#include <vector>
#include <iostream>
#include <set>
#include <algorithm>

using namespace std;

class Solution{
public:
    vector<int> get_result(vector<int> &nums)
    {
        vector<pair<int,int> > vec;
        vector<int> count;
        for (int i=0; i<nums.size(); i++){
            vec.push_back(make_pair(nums[i],i));
            count.push_back(0);
        }
        
        merge_sort(vec,count);
        return count;
    }

private:
    void merge_sort_two_vec(vector<pair<int,int> > &vec,vector<pair<int,int> > &sub_vec1,vector<pair<int,int> > &sub_vec2,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){
                vec.push_back(sub_vec1[i]);
                count[sub_vec1[i].second] += j;
                i++;
            }else{
                vec.push_back(sub_vec2[j]);
                j++;
            }
        }
        
        for(;i<sub_vec1.size();i++){
            vec.push_back(sub_vec1[i]);
            count[sub_vec1[i].second] += j;
        }
        
        for(;j<sub_vec2.size();j++){
            vec.push_back(sub_vec2[j]);
        }
        
       return; 
    }

    void merge_sort(vector<pair<int,int> > &vec,vector<int> &count)
    {
        vector<pair<int,int> > sub_vec1;
        vector<pair<int,int> > sub_vec2;

        if (vec.size() < 2){
            return;
        }
 
        int mid=vec.size()/2;
        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(vec,sub_vec1,sub_vec2,count);
        
        return;
    }    
};

int main()
{ 
    Solution solve;
    vector<int> vec;
    vector<int> result;
    int nums[]={2,5,8,10,1,3,5,7,30,50};
    
    for (int i=0; i<sizeof(nums)/sizeof(int); i++){
        vec.push_back(nums[i]);
    }
    
    result=solve.get_result(vec);
    
    for (int i=0; i<result.size(); i++){
        cout << result[i]<<" ";
    }
    cout << "\n";
    
    return 0;
}