LeetCode 关于回溯、递归的一些解题

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

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);

}

class Solution
{
public:
    /***************************************************
    *  函数功能： 求数组的子集，回溯法
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(2^n)，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/subsets/description/
    *  日期：2018-06-28-19.54
    ***************************************************/
    vector<vector<int> > subsets(vector<int>& nums)
    {
        vector<int> item;
        vector<vector<int> > result;
        result.push_back(item);
        if(nums.size()<1) return result;
        generates(0,nums,item,result);
        return result;
    }
    /***************************************************
    *  函数功能：求数组的子集，利用位运算的思想
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/subsets/description/
    *  日期：2018-06-28-21.23
    ***************************************************/
    vector<vector<int> > subsetss(vector<int>& nums)
    {
        int all_sets=1<<nums.size();
        vector<vector<int> > result;
        for(int i=0;i<all_sets;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;
    }
    /***************************************************
    *  函数功能：求数组中等于目标值的所有不同元素的子集
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ：
    *  日期：2018-06-28-21.23
    ***************************************************/
    vector<vector<int> > subsetss_target(vector<int>& nums,int target)
    {
        int all_sets=1<<nums.size();
        vector<vector<int> > result;
        for(int i=0;i<all_sets;i++)
        {
            vector<int> item;
            int number=0;
            for(int j=0;j<nums.size();j++)
            {
                if(i & 1<<j)
                {
                    item.push_back(nums[j]);
                    number+=nums[j];
                }
            }
            if(number==target)
            {
               result.push_back(item);
            }
        }
        return result;
    }
    /***************************************************
    *  函数功能：求数组中等于目标值的所有不同元素的子集
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/subsets-ii/description/
    *  日期：2018-06-28-21.23
    ***************************************************/
    vector<vector<int> > subsetsWithDup(vector<int>& nums)
    {
        vector<vector<int> > result;
        vector<int> item;
        result.push_back(item);
        set<vector<int> > set_vec;
        sort(nums.begin(),nums.end());
        generatess(0,nums,item,result,set_vec);
        return result;

    }
    vector<vector<int> > subsetsWithDup1(vector<int>& nums)
    {
        vector<vector<int> > result;
        vector<int> item;
        result.push_back(item);
        sort(nums.begin(),nums.end());
        dfs(0,nums,item,result);
        return result;
    }
    /***************************************************
    *  函数功能：求重复数组中为目标值的子数组
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/combination-sum-ii/description/
    *  日期：2018-06-29-20.20
    ***************************************************/
    vector<vector<int> > combinationSum2(vector<int>& candidates,int target)
    {
        vector<int> item;
        vector<vector<int> > result;
        set<vector<int> > res_num;
        int sum=0;
        sort(candidates.begin(),candidates.end());
        dfs1(0,candidates,item,res_num,result,target,sum);

        return result;
    }

    vector<vector<int> > combinationSum3(vector<int>& candidates,int target)
    {
        vector<int> item;
        vector<vector<int> > result;
        sort(candidates.begin(),candidates.end());
        if(candidates.size()<1 && target<candidates[0]) return result;

        dfs2(0,candidates,item,result,target);
        return result;
    }
    /***************************************************
    *  函数功能：生成合法括号
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/generate-parentheses/description/
    *  日期：2018-06-29-21.14
    ***************************************************/
    vector<string> generateParenthesis(int n)
    {
        vector<string> result;
        if(n<1) return result;
        dfs3("",n,n,result);
        return result;
    }
    /***************************************************
    *  函数功能：N皇后问题
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/n-queens/description/
    *  日期：2018-06-29-22.12
    ***************************************************/
    vector<vector<string> > solveNQueen(int n)
    {
        vector<string> item;
        vector<vector<string> > result;
        vector<vector<int> > 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);
            }
            item.push_back("");
            item[i].append(n,'.');
        }
        geneateQueen(0,n,item,result,mark);
        return result;
    }

private:
    void geneateQueen(int k,int n,vector<string>& item,vector<vector<string> >&result,vector<vector<int> >& mark)
    {
        if(k==n)
        {
            result.push_back(item);
            return ;
        }
        for(int i=0;i<n;i++)
        {
            if(mark[k][i]==0)
            {
                vector<vector<int> > temp_mark=mark;
                putQueen(k,i,mark);
                item[k][i]='Q';
                geneateQueen(k+1,n,item,result,mark);
                item[k][i]='.';
                mark=temp_mark;
            }
        }
    }

    void putQueen(int x,int y,vector<vector<int> >& mark)
    {
        const static int dx[]={-1,-1,0,1,1,1,0,1};
        const static int dy[]={0,-1,-1,-1,0,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 dfs3(string item,int left,int right,vector<string>& result)
    {
        if(left==0 && right==0)
        {
            result.push_back(item);
            return ;
        }
        if(left>0)
        {
            dfs3(item+"(",left-1,right,result);
        }
        if(left<right)
        {
            dfs3(item+")",left,right-1,result);
        }
    }


    void dfs2(int start,vector<int>& candidates,vector<int>& item,vector<vector<int> >& result,int target)
    {
        if(!target)
        {
           result.push_back(item);
        }
        for(int i=start;i<candidates.size() && target>=candidates[i];i++)
        {
            item.push_back(candidates[i]);
            dfs2(i+1,candidates,item,result,target-candidates[i]);
            item.pop_back();

            while(i<candidates.size()-1 && candidates[i]==candidates[i+1])
            {
                i++;
            }

        }
    }

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

    }
    void dfs(int i,vector<int>& nums,vector<int>& item,vector<vector<int> >& result)
    {
        if(i>=nums.size())
        {
            return ;
        }

        while(i<nums.size())
        {
            item.push_back(nums[i]);
            result.push_back(item);
            dfs(i+1,nums,item,result);
            item.pop_back();
            int next=i+1;
            while(next<nums.size() && nums[i]==nums[next])
            {
                next++;
            }
            i=next;
        }
    }

    void generatess(int i,vector<int>& nums,vector<int>& item,vector<vector<int> >& result,set<vector<int> >& set_vec)
    {
        if(i>=nums.size())
            return ;
        item.push_back(nums[i]);
        if(set_vec.find(item)==set_vec.end())
        {
            set_vec.insert(item);
            result.push_back(item);
        }
        generatess(i+1,nums,item,result,set_vec);
        item.pop_back();
        generatess(i+1,nums,item,result,set_vec);
    }

    void generates(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);
        generates(i+1,nums,item,result);
        item.pop_back();
        generates(i+1,nums,item,result);
    }
};


int main()
{
    Solution ss;
    vector<vector<string> > result;
    result=ss.solveNQueen(4);
    for(int i=0;i<result.size();i++)
    {
        for(int j=0;j<result[i].size();j++)
        {
            cout<<result[i][j]<<endl;
        }
        cout<<endl;
    }


    return 0;
}
/*
int main()
{
    Solution ss;
    vector<string> result;
    result=ss.generateParenthesis(3);
    for(int i=0;i<result.size();i++)
    {
        cout<<result[i]<<endl;
    }
    return 0;
}
*/

/*
void generatess(string item,int n,vector<string>& result)
{
    if(2*n==item.length())
    {
        result.push_back(item);
        return ;
    }
    generatess(item+"<",n,result);
    generatess(item+">",n,result);

}
int main()
{
    vector<string> result;
    generatess("",2,result);
    cout<<"number: "<<result.size()<<endl;
    for(int i=0;i<result.size();i++)
    {
        cout<<result[i]<<endl;
    }

    string aa="abcd";
    cout<<aa.size()<<"  "<<aa.length()<<endl;

    return 0;
}
*/

/*
int main()
{
    Solution ss;

    int a[]={10,1,2,7,6,1,5};
    int target=8;
    vector<int> nums;
    int len=sizeof(a)/sizeof(*a);
    for(int i=0;i<len;i++)
    {
        nums.push_back(a[i]);
    }
    vector<int> item;
    vector<vector<int> > result;
    //generate(0,nums,item,result);
    result=ss.combinationSum3(nums,target);
    for(int i=0;i<result.size();i++)
    {
        if(result[i].size()==0)
        {
            cout<<"[ ]";
        }
        for(int j=0;j<result[i].size();j++)
        {
            cout<<"["<<result[i][j]<<"]";

        }
        cout<<endl;
    }

    return 0;
}
*/

/*
int main()
{
    Solution ss;

    int a[]={2,1,2,2};
    vector<int> nums;
    int len=sizeof(a)/sizeof(*a);
    for(int i=0;i<len;i++)
    {
        nums.push_back(a[i]);
    }
    vector<int> item;
    vector<vector<int> > result;
    //generate(0,nums,item,result);
    result=ss.subsetsWithDup1(nums);
    for(int i=0;i<result.size();i++)
    {
        if(result[i].size()==0)
        {
            cout<<"[ ]";
        }
        for(int j=0;j<result[i].size();j++)
        {
            cout<<"["<<result[i][j]<<"]";

        }
        cout<<endl;
    }

    return 0;
}
*/

/*
int main()
{
    Solution ss;

    int a[]={1,2,3,4,5,6};
    vector<int> nums;
    int len=sizeof(a)/sizeof(*a);
    for(int i=0;i<len;i++)
    {
        nums.push_back(a[i]);
    }
    vector<int> item;
    vector<vector<int> > result;
    //generate(0,nums,item,result);
    result=ss.subsetss_target(nums,10);
    for(int i=0;i<result.size();i++)
    {
        if(result[i].size()==0)
        {
            cout<<"[ ]";
        }
        for(int j=0;j<result[i].size();j++)
        {
            cout<<"["<<result[i][j]<<"]";

        }
        cout<<endl;
    }

    return 0;
}
*/


/*
void compute_sum(int i,int& sum)
{
    if(i>3)
        return ;
    sum+=i;
    compute_sum(i+1,sum);
}
struct ListNode
{
    int val;
    ListNode* next;
    ListNode(int x):val(x),next(NULL){}
};

void add_to_vector(ListNode* head,vector<int>& vec)
{
    if(!head)
    {
        return ;
    }
    vec.push_back(head->val);
    add_to_vector(head->next,vec);
}
int main()
{
    int sum=0;
    compute_sum(0,sum);
    cout<<sum<<endl;
    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;
    vector<int> vec;
    add_to_vector(&a,vec);
    for(int i=0;i<vec.size();i++)
    {
        cout<<vec[i]<<" ";
    }
    cout<<endl;
    cout<< "Hello world!" << endl;
    return 0;
}
*/