前言

动态规划是把复杂的问题拆分成一个个小问题，然后把上个问题的解作为条件来解决下一个问题，以此类推。

力扣：416. 分割等和子集

1. 题目

求一个数组是否可以分割成元素和相等的两个子集。
输入：[1,5,11,5]；输出：true。可以分割成 [1,5,5] 和 [11]。
输入：[1,2,5];输出：false。无法分割成元素和相等的两个子集。

2. 思路

第一步：两个子集和相等，则数组和必须为偶数(基+基=偶，偶+偶=偶)，否则返回false；
第二步：将其中一个子集之和作为 target ，判断数组中是否存在 target，如果存在则返回 true；
第三步：现在将问题集中到数组中是否存在子集之和为 target。初始化一个空数组 dp ，数组索引 j 表示 j 是否是任意子集之和，如果是，则 dp[j] = true。否则 dp[j] = false。所以现在需要计算 dp[target] 是 true 还是false。

循环数组，判断每个元素到 target 之间的每个值是否是任意子集之和。
比如 arr = [1,5,11,5]。target 为 11。所以就需要求 dp[11] 的值。
dp长度为11+1=12；初始化 dp[0]=true。其他可以假定为false。

循环数组[1,5,11,5] 。

第一个元素1。元素与 target 的区间就是[1-11]，循环这个数组区间，把数组区间的每个元素 j - 当前元素1 。需要注意的是，这里是 j 初始值为 target（11）, j- -。即由大到小递减，比如先计算11-1，再计算10-1，9-1 等等。如果从小到大减的话，dp[1] = dp[1-1]=dp[0]=true。dp[2]=dp[2-1]=dp[1]=true。这样每个 dp[j] 都是true。这个 dp 就会失效。而从大到小减的话，只能推测出 dp[1] = dp[1-1]=dp[0]= true。
即 dp[0]=true；dp[1] = true。

第二个元素5。元素与 target 的区间就是[5-11]，循环这个数组区间，把数组区间的每个元素 j - 当前元素5 。当 j = 6 时，dp[ 6-5 ] = dp[1]=true；当 j = 5 时，dp[ 5-5 ] = dp[0]=true；
即 dp[6]=true；dp[5] = true。

第三个元素11。元素与 target 的区间就是[11-11]，循环这个数组区间，把数组区间的每个元素 j - 当前元素11 。当 j = 11 时，dp[ 11-11 ] = dp[0]=true；
即 dp[11]=true。

到这里已经计算出 dp[11] 的值，则直接返回 true。

以上推理过程为，元素 arr[i] 与 target 的区间就是 [arr[i],target]，循环这个数组区间，把每个元素 j 减去当前元素arr[i]。根据已知 dp[j] 值，计算与之关联的 dp[j-arr[i]] 的值。

3. 代码

  var arr = [1,5,11,5];
  function canPartition(arr) {
      //计算数组元素总和
      let total = arr.reduce((total,item)=>{
          return total+item
      });
      //如果和不为偶数则直接返回 false
      if (total % 2 !== 0) return false;
      let target = total / 2;
      //如果数组中有target元素则直接返回 true
      if(arr.includes(target)){
          return true;
      };
      //初始化一个数组储存某个元素是否是子集之和，
      //由于要计算target是否为子集之和，所以数组长度为 target+1;
      let dp = new Array(target + 1);//或者直接[]   
      for(let i=0;i<arr.length;i++){
          dp[0] = true;//初始化 dp[0] 为 true
          for(let j=target;j>=arr[i];j--){
              dp[j] = dp[j]||dp[j-arr[i]];
              //如果target是子集之和则直接返回true
              if(dp[target]){
                  return true
              }
          }
      }
      return false
  }
  console.log(canPartition(arr));//true

最后

以上就是害羞雪糕为你收集整理的算法 - 分割等和子集（动态规划）前言1. 题目2. 思路3. 代码的全部内容，希望文章能够帮你解决算法 - 分割等和子集（动态规划）前言1. 题目2. 思路3. 代码所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。