Leetcode698.划分为k个相等的子集

题目：

解题思路：
首先这道题使用的深度优先搜索算法，通过分析题目可知，如果一个数组能分成k个总和相同的子集，那么首先我们要知道数组的总和除以k是否得到一个整数part_sum，这个part_sum就是我们子集的总和，如果除以k得不到一个整数，说明数组不可能划分，直接排除。所以当数组可以划分的情况下，使用深度搜索，从数组的第一个元素开始累加，如果大于目标总和，就递归返回，表示这个数不在对应子集中，于是探索下一个数，如此搜索下去，知道满足子集的总和等于part_sum，于是k–,也就是重复以上过程，知道满足遍历了数组所有的数，而且得到的子集数等于k，使用一个used数组来存放数组的访问状态。
代码如下：

class Solution {
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        if(nums.size()==1){
            if(k==1)return true;
            else return false;
        }
        if(nums.size()<k)return false;
        if(k==1)return true;
        
    int sum=0;
    for(int i=0;i<nums.size();i++){
        sum+=nums[i];
    }
    if(sum%k!=0)return false;    
        int part_sum=sum/k;  
     vector<int>used(nums.size(),0); 
        return dfs(nums,0,0,0,part_sum,k,used);
    }
 bool dfs(vector<int>&nums,int start,int n,int cursum,int target,int k,vector<int>&used)
 {
     if(cursum>target)return false;
     if(n==nums.size()&&k==0){return true;}
     if(cursum==target){
         return dfs(nums,0,n,0,target,k-1,used);
     }     
         for(int i=start;i<nums.size();i++){
             if(used[i]==0){
                 used[i]=1;
                 if(dfs(nums,i+1,n+1,cursum+nums[i],target,k,used)){
                     return true;
                 }
                 used[i]=0;
             }
         }
     
     return false;
 } 
    
    
    
    
    
    
    
    
};

结果：