深度优先算法--leetcode刷题总结

77 组合
唯一的要求就是组合中元素的个数，首先对从1到n-(k-path.size())+1的元素进行遍历，n-(k-path.size())+1是数组所能存储的最大值。访问完某一元素后要将该元素弹出。

class Solution {
public:
    vector<int>path;
    vector<vector<int>>ans;
    vector<vector<int>> combine(int n, int k) {
        dfs(n,k,1);
        return ans;
    }
    void dfs(int n,int k,int l)
    {
        if(path.size()==k)
        {
            ans.push_back(path);
            return;
        }
        for(int i=l;i<=n-(k-path.size())+1;i++)
        {
            path.push_back(i);
            dfs(n,k,i+1);
            path.pop_back();
        }
    }
};

080. 含有 k 个元素的组合

与第一题一样的，但解法有所不同。
即每个点都是可取可不取的，取和不去向下遍历得到的集合不一样，只要是满足题意的集合，就存入答案中。

class Solution {
public:
    vector<int>path;
    vector<vector<int>>ans;
    void dfs(int i,int k,int n)
    {
        
        if(path.size()==k)
        {
            ans.push_back(path);
            return ;
        }if(i>n)return ;
            path.push_back(i);
            dfs(i+1,k,n);
            path.pop_back();
            dfs(i+1,k,n);
    }
    vector<vector<int>> combine(int n, int k) {
        dfs(1,k,n);
        return ans;
    }
};

079 所有子集
深度优先搜索玩整个数组，而每个数组元素都是可取可不取的，故有：

class Solution {
public:
    vector<int>path;
    vector<vector<int>>ans;
    void dfs(int n,vector<int>nums)
    {
        if(n==nums.size())
        {
            ans.push_back(path);
            return ;
        }
        else
        {
            path.push_back(nums[n]);
            dfs(n+1,nums);
            path.pop_back();
            dfs(n+1,nums);
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(0,nums);
        return ans;
    }
};

允许重复选择元素的组合

每个点都是可取可不取的，不取那么继续向前遍历数组，取–将nums[idx]存入path中，因为可重复那么取某一元素的次数是任意的，把满足条件的集合放入答案中即可。

class Solution {
public:
    vector<vector<int>>ans;
    vector<int>path;
    void dfs(vector<int>nums,int target,int idx)
    {
        if(target==0)
        {
            ans.push_back(path);
            return ;
        }
        if(target<0||idx>=nums.size())
        {
            return ;
        }
        dfs(nums,target,idx+1);
        if(target-nums[idx]>=0)
        {
            path.push_back(nums[idx]);
            dfs(nums,target-nums[idx],idx);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        dfs(candidates,target,0);
        return ans;
    }
};

39. 组合总和

同上。