leetcode 划分为k个相等的子集（回溯）&& 分割等和子集 （dp）&&最后一块石头的重量 && 目标和

路径：递归路径
选择列表：nums
结束条件：k == 4

思路一：n个数字，每个数字都要选择进入到k个桶中的某一个

bool canPartitionKSubsets(vector<int>& nums, int k){
	if(k > nums.size())
		return false;
		
	vector<int> bucket(k, 0);
	int sum = 0;
	for(auto v : nums)
		sum += v;
	
	if(sum % k != 0) return false;
	
	int target = sum / k;
	
	//穷举，看看nums是否能划分为k个和为target的子集
	backtracking(nums, 0, bucket, target); 
}
void backtracing(vector<int> &nums, int index, vector<int> bucket, int target){
	if(index == nums.size()){
		//检查所有桶的数字之和是否都为target
		for(int i = 0; i < bucket.size(); i++)
			if(bucket[i] != target)
				return fasel;
		return true;
	}
	
	//穷举nums[index]可能装入的桶
	for(int i = 0; i < backet.size(); i++){
		if(bucket[i] + nums[index] > target)
			continue;
		bucket[i] += nums[index];
		backtracking(nums, bucket, index + 1, target);
		bucket[i] -= nums[index];
	}
	
	//nums[index]装到哪个桶都不行
	return false;
}

思路二：以桶为视角进行穷举。每个桶需要遍历nums中的n个数字，决定是否应该将该数字放入桶中。当装满一个桶后，还要装下一个桶，直到所有桶都装满为止。

bool canPartitionKSubsets(vector<int> nums, int k){
	//排除一些基本情况
	if(k > nums.size()) return false;
	int sum = 0;
	for(int v : nums) sum += v;
	if(sum % k != 0)  return false;
	
	vector<bool> used(nums.size(), false);
	int target = sum / k;
	//k号桶初试什么都没有装，从nums[0]开始选择
	return backtrack(k, 0, nums, 0, used);
}

这个backtrack函数的参数可以这样解释：

现在k号桶正在思考是否应该把nums[start]这个元素装进来；目前k号桶里面已经装的数字之和为bucket；used标志某一个元素是否已经被装到桶中；target是每个桶需要达成的目标和

从桶的视角：

1. 需要遍历nums中的所有数字，决定哪些数字需要装到当前桶中。
2. 如果当前桶装满了，则让下一个桶进行第1步。

bool backtrack(int k, int bucket, vector<int> nums, int start, vector<bool> used, int target){
	if(k == 0){
		return true;
	}
	if(bucket == target){
, 		return backtrack(k-1, 0, nums, 0, used, target);
	}
	
	for(int i = start; i < nums.size(); i++){
		if(used[i])
			continue;
		if(nums[i] + bucket > target)
			continue;
		







		used[i] = true;
		bucket += nums[i];
		
		if(backtrack(k, bucket, nums, i+1, used, target))
			return true;
		
		used[i] = false;
		bucket -= nums[i];
	}
	return false;
}

转化为0-1背包问题，即集合里面的是否存在总和为sum/2的元素刚好可以把容量为sum/2的背包装满。 每个元素相当于其重量为num[i], 价值为num[i]，背包容量为sum / 2;

二维：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
//num里面的物品能否装满容量为sum/2的背包
        int sum = 0;
        for(int &v : nums) sum += v;
        if(sum % 2 != 0) return false;
//物品重量为num[i]，物品价值也为num[i]
        vector<vector<int> > dp(nums.size(), vector<int>(sum / 2 + 1, 0));

        //初始化物品0
        for(int j = nums[0]; j <= sum/2; j++) dp[0][j] = nums[0];

        //dp[i][j]表示0-i里面的物品能否装满容量为j的背包
        
        //先遍历物品再遍历背包
        for(int i = 1; i < nums.size(); i++){
            for(int j = 0; j <= sum/2; j++){
                if(nums[i] > j) dp[i][j] = dp[i-1][j];
                else dp[i][j] = max(dp[i-1][j], dp[i-1][j - nums[i]] + nums[i]);
            }
        }

        if(dp[nums.size() - 1][sum / 2] ==  sum / 2) return true;
        return false;
    }
};

一维：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
//num里面的物品能否装满容量为sum/2的背包
        int sum = 0;
        for(int &v : nums) sum += v;
        if(sum % 2 != 0) return false;
//物品重量为num[i]，物品价值也为num[i]
        vector<int> dp(sum / 2 + 1, 0);

        //初始化物品0
        //for(int j = nums[0]; j <= sum/2; j++) dp[0][j] = nums[0];

        //dp[i][j]表示0-i里面的物品能否装满容量为j的背包
        
        //先遍历物品再遍历背包
        for(int i = 1; i < nums.size(); i++){
            for(int j = sum/2; j >= nums[i]; j--){
                if(nums[i] > j) dp[j] = dp[j];
                else dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }

        if(dp[sum / 2] ==  sum / 2) return true;
        return false;
    }
};

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(auto v : nums) sum += v;
        
        if(sum % 2 != 0) return false;
        
        sum = sum / 2;
        
        vector<int> dp(sum + 1);
        dp[0] = 0;
        
        for(int i = 1; i < nums.size(); i++){
            for(int j = sum; j >= nums[i]; j--){
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
                
                if(dp[j] == sum) return true;
            }
        }
        
        return false;
    }
};

思路：此题相当于要把石头分为尽量相等的两堆，最后一块石头的重量就是这两堆的差值。故于上题的分割等和子集思路一致。

1. dp[i]表示重量为i的背包能背的最大重量的石头
2. 递推公式：dp[j] = max(dp[j], dp[j-stones[i]] + stones[i])
3. dp数组初始化。都初始化为0就行了，这样在递推公式里面dp[j]才不会被初始值所覆盖。因为0已经是重量了里面最小的了，重量不可能为负值

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        //尽量将石头分为相同的两堆
        
        //dp[i]表示重量为i的背包最多能背的石头重量
        int sum = 0;
        for(int &v : stones) sum += v;

        int target = sum / 2;
        vector<int> dp(target+1, 0);

        //先遍历物品 再遍历背包
        for(int i = 0; i < stones.size(); i++){
            for(int j = target; j >=stones[i]; j--){
                dp[j] = max(dp[j], dp[j-stones[i]] + stones[i]);
            }
        }

        int res = (sum - dp[target]) - dp[target];

        return res;

    }
};

思路：题目换种意思就是说将target分成两堆，一堆减去另外一堆等于target有几种组合方法。
有left - right = target， 又left+right = sum
固有left = (sum + target) / 2。
由等式可知限制条件有(sum + target)需为偶数，且abs(target) < sum；
题目则变为装满容量为left的背包，有多少种装法，变成了一种组合问题(故也可以使用回溯法)
为什么这题可以使用01背包呢，因为nums里面的数只能取或者不取，且只能取一次。

1. dp[j]表示装满容量为j的背包，有dp[j]种方法
2. 确定递推公式：dp[i]可以由dp[j - nums[i]]推导而来：填满j - nums[i]的背包有dp[j - nums[i]]种方法，则只要弄到nums[i]的话，装满重量为j的背包就有dp[i] + dp[j - nums[i]]种办法
3. 初始化：由递推公式可知，应该从前往后遍历，故dp[0] = 1而不是dp[0] = 0，即装满容量为0的背包，有1种方法，即什么都不装

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        //left组合 - right组合 = target
        //left + right = sum
        //left - (sum - left) = target
        //left = (target + sum)/2

        //问题变为在nums中找到目标和为left的集合
        int sum = 0;
        for(int &v : nums) sum += v;

        //因为left必定是整数，因为nums数组全是正整数
        if((target + sum) % 2 == 1) return 0;
        if(abs(target) > sum) return 0;


        int left = (target + sum)/2;

        vector<int> dp(left + 1, 0);
        dp[0] = 1;
        //dp[j]装满容量为j的背包有多少种方法

        for(int i = 0; i < nums.size(); i++){
            for(int j = left; j >= nums[i]; j--){
                dp[j] += dp[j - nums[i]];
            }
        }

        return dp[left];


    }
};