LeetCode刷题之HOT100之分割等和子集

2024 7/19 不知道以什么开场，可能是闷热的天气将我的思绪笼罩，让我昏昏沉沉，也可能是昨晚糟糕的睡眠让大脑cpu运行变慢，困意袭来。做题吧

1、题目描述

2、算法分析

分割等和子集，题目要求很简单，给定数组，判断是否能将该数组一分为二，且两个子集数组元素和相等。So，How should i do？我还真想不出来什么算法啊。
打开题目->思索半天->打开题解->思索一会->妙不可言->我是废物

canPartition 方法的算法思想主要基于动态规划（Dynamic Programming, DP）。动态规划是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。这些子问题互相重叠，且解决子问题后，其结果会被保存起来，以便后续需要时直接利用，从而避免了重复计算。
在 canPartition 方法中，动态规划的思想体现在以下几个方面：

1. 定义状态： 定义一个二维数组 dp，其中 dp[i][j] 表示从前 i 个元素（即数组 nums 的前 i
   个元素）中是否可以选择若干个数，使得它们的和为 j。这是一个布尔值，true 表示可以，false 表示不可以。
2. 初始化状态： 初始化 dp 数组的第一列（即 j = 0 的情况）为 true，因为任何数的组合都可以通过不选择任何数来得到和为 0的子集。同时，如果数组的第一个元素 nums[0] 等于目标和 target 的一部分（尽管这在实际应用中很少见），则dp[0][nums[0]] 也应被初始化为 true。但在这个特定的问题中，我们主要关注的是第一列的初始化。
3. 状态转移方程： 对于每个 dp[i][j]（i > 0, j > 0），我们有两种选择： 不选择第 i 个元素nums[i]，那么问题就转化为判断前 i-1 个元素是否能组成和为 j 的子集，即 dp[i][j] = dp[i-1][j]。选择第 i 个元素 nums[i]，那么问题就转化为判断前 i-1 个元素是否能组成和为 j-nums[i] 的子集，即dp[i][j] = dp[i-1][j-nums[i]]（但前提是 j >= nums[i]）。
   综合这两种情况，我们得到状态转移方程：

  dp[i][j] = dp[i−1][j] || dp[i − 1][j − nums[i]]( j ≥ nums[i]) 

 dp[i][j] = dp[i - 1][j](j <nums[i]) 

4. 边界条件： 在处理状态转移时，需要注意边界条件，如 j 是否小于 nums[i]，以及数组索引是否越界等。
5. 目标状态： 最终的目标是判断 dp[len-1][target] 是否为 true，其中 len 是数组 nums 的长度，target是目标和（即数组元素总和的一半）。如果 dp[len-1][target] 为 true，则表示整个数组可以被分割成两个和相等的子集。

3、代码

public boolean canPartition(int[] nums) {  
    // 数组长度小于2，无法分割成两个非空子集，直接返回false  
    int len = nums.length;  
    if(len < 2){  
        return false;  
    }  
      
    // 计算数组元素的总和以及最大元素  
    int sum = 0, maxNum = 0;  
    for(int num : nums){  
        sum += num;  
        maxNum = Math.max(maxNum, num);  
    }  
      
    // 如果总和为奇数，则无法平均分割成两个相等的子集，返回false  
    if(sum % 2 != 0){  
        return false;  
    }  
      
    // 目标值，即我们想要分割成的两个子集的目标和  
    int target = sum / 2;  
      
    // 如果最大元素已经大于目标和的一半，那么无法将剩余元素组成和为目标和的子集，返回false  
    if(maxNum > target){  
        return false;  
    }  
      
    // 创建一个二维数组dp，用于动态规划。dp[i][j]表示前i个元素是否能组成和为j的子集  
    boolean[][] dp = new boolean[len][target + 1];  
      
    // 初始化dp数组的第一列，表示和为0的子集总是可以组成的  
    for(int i = 0; i < len; i++){  
        dp[i][0] = true;  
    }  
      
    // 第一个元素如果能直接等于目标和（虽然这种情况几乎不会发生），则设置为true  
    dp[0][nums[0]] = true;  
      
    // 动态规划过程  
    for(int i = 1; i < len; i++){  
        int num = nums[i];  
        for(int j = 1; j <= target; j++){  
            // 如果当前元素num小于等于当前目标和j  
            // 那么有两种可能：要么不使用num（dp[i-1][j]），要么使用num（dp[i-1][j-num]）  
            if(j >= num){  
                dp[i][j] = dp[i -1][j] || dp[i - 1][j - num];  
            }else{  
                // 如果num大于j，则无法使用num来组成和为j的子集，只能沿用前一个状态  
                dp[i][j] = dp[i - 1][j];  
            }  
        }  
    }  
      
    // 返回dp数组的最后一个元素，即所有元素是否能组成和为目标和的子集  
    return dp[len - 1][target];  
}

优化：
虽然在这个特定的问题中，我们使用了二维数组 dp，但实际上可以通过优化空间复杂度，只使用一维数组来解决问题。这是因为在填充 dp[i][j] 时，我们只需要知道 dp[i-1][…] 的值，而不需要知道更早之前的状态。这种优化将空间复杂度从 O(n*target) 降低到 O(target)，其中 n 是数组长度，target是目标和加 1（因为数组索引从 0 开始）。

// 定义一个布尔数组dp，长度为目标和加1。dp[j]表示是否存在一个子集其和为j  
boolean[] dp = new boolean[target + 1];  
// 初始化dp[0]为true，表示存在一个和为0的子集（即不选择任何元素）  
dp[0] = true;  
  
// 遍历数组nums中的每个元素  
for(int i = 0; i < len; i++){  
    int num = nums[i]; // 当前遍历到的元素  
    // 从目标和target开始向下遍历到当前元素num（包括num），注意这里是逆序遍历  
    for(int j = target; j >= num; j--){  
        // 更新dp[j]的值：如果之前已经存在一个和为j-num的子集，  
        // 那么加上当前元素num后，就可以得到一个和为j的子集  
        // 使用逻辑或操作符||，因为只要dp[j]或dp[j-num]中有一个为true，dp[j]就可以被更新为true  
        dp[j] = dp[j] || dp[j - num];  
    }  
}  
  
// 返回dp[target]的值，即判断是否存在一个和为目标和的子集  
return dp[target];

复杂度分析

• 时间复杂度：O(n * target)，其中 n 是数组的长度，target是整个数组的元素和的一半。需要计算出所有的状态，每个状态在进行转移时的时间复杂度为 O(1)。
• 空间复杂度：O(target)，其中 target 是整个数组的元素和的一半。空间复杂度取决于 dp数组，在不进行空间优化的情况下，空间复杂度是 O(n * target)，在进行空间优化的情况下，空间复杂度可以降到 O(target)

就到这里吧，再见~