LeetCode:判断能否将这个数组分割成两个子集,使得两个子集的元素之和相等

最新推荐文章于 2024-09-23 10:32:59 发布

路上的追梦人

最新推荐文章于 2024-09-23 10:32:59 发布

阅读量1.7k

点赞数

分类专栏： LeetCode 文章标签：剪枝算法 leetcode 动态规划 dfs

本文链接：https://blog.csdn.net/Jiangtagong/article/details/113871989

版权

LeetCode 专栏收录该内容

179 篇文章 8 订阅

订阅专栏

该博客讨论了一种常见的编程问题，即判断一个包含正整数的数组能否被分割成两个子集，使得两子集的元素和相等。作者提出了两种解题方法：深度优先搜索（DFS）加剪枝优化，以及动态规划。尽管DFS方法因超时未通过，但动态规划解决方案通过创建一个dp数组来跟踪目标和的子集是否存在，从而有效地解决了问题。该博客适合对算法和动态规划感兴趣的读者。

摘要由CSDN通过智能技术生成

Given a non-empty array containing only positive integers,find if the array can be 
partitioned to two subsets such that the sum of elements in both subsets is equal.

Note:
1.Each of the array element will not exceed 100.
2.The array size will not exceed 200.

Example 1:
Input:[1,5,11,5]
Output:true
Explanation:
The array can be partitioned as [1,5,5] and [11].

Example 2:
Input:[1,2,3,5]
Output:false
Explanation:
The array cannot be partitioned into equal sum subsets.

题目大意:
给定一个只包含正整数的非空数组,是否可以将这个数组分割成两个子集,使得两个子集的元素之和相等.

解题思路:
方法1:
dfs+剪枝优化
要满足sum(P)=sum(Q),根据sum(P)+sum(Q)=sum(nums),可得sum(P)=sum(nums)/2.此问题转换为
在数组中找出是否存在子集满足target=sum(nums)/2.
只要找到一个temp值等于target即可返回,剪枝的条件是在枚举数组中temp!=target,此外路径之和不能大于target.
可惜超时。

方法2:
动态规划

Go语言实现

package main

import (
	"fmt"
	"math"
)

func canPartition(nums []int)bool{
	flag:=false
	sum,temp:=0,0
	for _,num:=range nums{
		sum+=num
	}
	if sum%2!=0{//sum为奇数,直接返回false
		return false
	}
	dfs(nums,sum/2,0,0,&temp)
	if(temp==sum/2){
		flag=true
	}
	return flag
}

func dfs(nums []int,sum int,index int,ans int,temp *int){
	if index>=len(nums){
		return
	}
	if ans==sum{
		*temp=sum
		return
	}
	for i:=index;i<len(nums)&&(*temp)!=sum;i++{//剪枝(*temp)!=sum、ans+nums[i]>sum
		if ans+nums[i]>sum{
			continue
		}
		ans+=nums[i]
		fmt.Println(ans," ",sum)
		dfs(nums,sum,i+1,ans,temp)
		ans-=nums[i]
	}
}


func canPartitionOne(nums []int)bool{
	sum:=0
	maxNum:=math.MinInt64
	for _,num:=range nums{
		sum+=num
		maxNum=Max(maxNum,num)
	}
	target:=sum>>1
	if sum%2!=0||target<maxNum{//sum为奇数,直接返回false
		return false
	}
	if target==maxNum{
		return true
	}
	dp:=make([]int,target+1)
	dp[0]=1//初始化key为0时,value为1个
	for _,i:=range nums{
		for j:=target;j>=i;j--{
			dp[j]+=dp[j-i]
		}
		if dp[target]!=0{//表示已经找到一组子集满足条件
			return true
		}
	}
	return false
}

func Max(a,b int)int{
	if a>b{
		return a
	}
	return b
}
func main(){
	nums:=[]int{14,9,8,4,3,2,4,6}
	//fmt.Println(canPartition(nums))
	fmt.Println(canPartitionOne(nums))
}