1、分割等和子集
//给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
//
//
//
// 示例 1:
//
//
//输入:nums = [1,5,11,5]
//输出:true
//解释:数组可以分割成 [1, 5, 5] 和 [11] 。
//
// 示例 2:
//
//
//输入:nums = [1,2,3,5]
//输出:false
//解释:数组不能分割成两个元素和相等的子集。
//
//
//
//
// 提示:
//
//
// 1 <= nums.length <= 200
// 1 <= nums[i] <= 100
//
// Related Topics 数组 动态规划
分割等和子集实质上还是一个在数组中寻找一些数,查看能否用他们的和来组成题设结果。因为对半开,所以我们只需要在数组中找到这么一些数让他们之和是sum/2.
所以采用动态规划,这个时候需要用到一个二维数组,dp[i][j]
表示在[0,i]
的范围内选取一些元素,使他们的和等于j,可以一个都不选,最后的结果就是dp[nums.length-1][target]
,所以我们可以推一下他们与前后项的关系,根据我们的假设,肯定有dp[i][0]==true
,还有dp[0][nums[0]]==0
,除此之外我们分两种情况进行讨论,第一如果nums[i]<=j,如果不选nums[i]则需要满足dp[i][j]=dp[i-1][j]
,如果选择num[i]就有dp[i-1][j-nums[i]]
,如果nums[i]>j,则nums[i]绝对不能选,就有dp[i][j]=dp[i-1][j]
public boolean canPartition(int[] nums) {
int n = nums.length;
if (n < 2) {
return false;
}
int sum = 0, maxNum = 0;
for (int num : nums) {
sum += num;
maxNum = Math.max(maxNum, num);
}
if (sum % 2 != 0) {
return false;
}
int target = sum / 2;
if (maxNum > target) {
return false;
}
//维护一个数组,dp[i][j]代表在[0,i]中选取一些数看看能不能组成j,可以不选
boolean[][] dp = new boolean[n][target + 1];
for (int i = 0; i < n; i++) {
dp[i][0] = true;
}
dp[0][nums[0]] = true;
for (int i = 1; i < n; i++) {
int num = nums[i];
for (int j = 1; j <= target; j++) {
if (j >= num) {
//可以选择选num[i]或者不选num[i]
dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n - 1][target];
}
2、路径总和III
//给定一个二叉树,它的每个结点都存放着一个整数值。
//
// 找出路径和等于给定数值的路径总数。
//
// 路径不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。
//
// 二叉树不超过1000个节点,且节点数值范围是 [-1000000,1000000] 的整数。
//
// 示例:
//
// root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
//
// 10
// /
// 5 -3
// / \
// 3 2 11
// / \
//3 -2 1
//
//返回 3。和等于 8 的路径有:
//
//1. 5 -> 3
//2. 5 -> 2 -> 1
//3. -3 -> 11
//
// Related Topics 树 深度优先搜索 二叉树
路径总和我们可以看成是深度之差,在同一个路径之下(可以理解成二叉树从root节点出发,到叶子节点的某一条路径),如果两个数的前缀总和是相同的,那么这些节点之间的元素总和为零。进一步扩展相同的想法,如果前缀总和currSum,在节点A和节点B处相差target,则位于节点A和节点B之间的元素之和是target。
抵达当前节点(即B节点)后,将前缀和累加,然后查找在前缀和上,有没有前缀和currSum-target的节点(即A节点),存在即表示从A到B有一条路径之和满足条件的情况。结果加上满足前缀和currSum-target的节点的数量。然后递归进入左右子树
对解析进行了一个详尽的分析:
https://leetcode-cn.com/problems/path-sum-iii/solution/dui-qian-zhui-he-jie-fa-de-yi-dian-jie-s-dey6/
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int pathSum(TreeNode root, int sum) {
// key是前缀和, value是大小为key的前缀和出现的次数
Map<Integer, Integer> prefixSumCount = new HashMap<>();
// 前缀和为0的一条路径
prefixSumCount.put(0, 1);
// 前缀和的递归回溯思路
return recursionPathSum(root, prefixSumCount, sum, 0);
}
/**
* 前缀和的递归回溯思路
* 从当前节点反推到根节点(反推比较好理解,正向其实也只有一条),有且仅有一条路径,因为这是一棵树
* 如果此前有和为currSum-target,而当前的和又为currSum,两者的差就肯定为target了
* 所以前缀和对于当前路径来说是唯一的,当前记录的前缀和,在回溯结束,回到本层时去除,保证其不影响其他分支的结果
* @param node 树节点
* @param prefixSumCount 前缀和Map
* @param target 目标值
* @param currSum 当前路径和
* @return 满足题意的解
*/
private int recursionPathSum(TreeNode node, Map<Integer, Integer> prefixSumCount, int target, int currSum) {
// 1.递归终止条件
if (node == null) {
return 0;
}
// 2.本层要做的事情
int res = 0;
// 当前路径上的和
currSum += node.val;
//---核心代码
// 看看root到当前节点这条路上是否存在节点前缀和加target为currSum的路径
// 当前节点->root节点反推,有且仅有一条路径,如果此前有和为currSum-target,而当前的和又为currSum,两者的差就肯定为target了
// currSum-target相当于找路径的起点,起点的sum+target=currSum,当前点到起点的距离就是target
res += prefixSumCount.getOrDefault(currSum - target, 0);
// 更新路径上当前节点前缀和的个数
prefixSumCount.put(currSum, prefixSumCount.getOrDefault(currSum, 0) + 1);
//---核心代码
// 3.进入下一层
res += recursionPathSum(node.left, prefixSumCount, target, currSum);
res += recursionPathSum(node.right, prefixSumCount, target, currSum);
// 4.回到本层,恢复状态,去除当前节点的前缀和数量
prefixSumCount.put(currSum, prefixSumCount.get(currSum) - 1);
return res;
}
}