xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-27 00:16:30 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-06-25 21:59:15 +08:00
parent e4e6cd6bae
commit c0b24f1d8f
1 changed files with 78 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

87
chapter_backtracking/subset_sum_problem.md
View file

@ -125,15 +125,35 @@ comments: true
=== "Go"
```go title="subset_sum_i_naive.go"
[class]{}-[func]{backtrackINaive}
/* 回溯算法：子集和 I */
func backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时，记录解
if target == total {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
for i := 0; i < len(*choices); i++ {
// 剪枝：若子集和超过 target ，则跳过该选择
if total+(*choices)[i] > target {
continue
}
// 尝试：做出选择，更新元素和 total
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)
// 回退：撤销选择，恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 I（包含重复子集） */
func subsetSumINaive(nums []int, target int) [][]int {
s := subset{}
state := make([]int, 0) // 状态（子集）
total := 0 // 子集和
res := make([][]int, 0) // 结果列表（子集列表）
s.backtrack(total, target, &state, &nums, &res)
backtrackSubsetSumINaive(total, target, &state, &nums, &res)
return res
}
```
@ -364,16 +384,38 @@ comments: true
=== "Go"
```go title="subset_sum_i.go"
[class]{}-[func]{backtrackI}
/* 回溯算法：子集和 I */
func backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时，记录解
if target == 0 {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
// 剪枝二：从 start 开始遍历，避免生成重复子集
for i := start; i < len(*choices); i++ {
// 剪枝一：若子集和超过 target ，则直接结束循环
// 这是因为数组已排序，后边元素更大，子集和一定超过 target
if target-(*choices)[i] < 0 {
break
}
// 尝试：做出选择，更新 target, start
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)
// 回退：撤销选择，恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 I */
func subsetSumI(nums []int, target int) [][]int {
s := subsetI{}
state := make([]int, 0) // 状态（子集）
sort.Ints(nums) // 对 nums 进行排序
start := 0 // 遍历起始点
res := make([][]int, 0) // 结果列表（子集列表）
s.backtrack(start, target, &state, &nums, &res)
backtrackSubsetSumI(start, target, &state, &nums, &res)
return res
}
```
@ -614,16 +656,43 @@ comments: true
=== "Go"
```go title="subset_sum_ii.go"
[class]{}-[func]{backtrackII}
/* 回溯算法：子集和 II */
func backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时，记录解
if target == 0 {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
// 剪枝二：从 start 开始遍历，避免生成重复子集
// 剪枝三：从 start 开始遍历，避免重复选择同一元素
for i := start; i < len(*choices); i++ {
// 剪枝一：若子集和超过 target ，则直接结束循环
// 这是因为数组已排序，后边元素更大，子集和一定超过 target
if target-(*choices)[i] < 0 {
break
}
// 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
if i > start && (*choices)[i] == (*choices)[i-1] {
continue
}
// 尝试：做出选择，更新 target, start
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)
// 回退：撤销选择，恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 II */
func subsetSumII(nums []int, target int) [][]int {
s := subsetII{}
state := make([]int, 0) // 状态（子集）
sort.Ints(nums) // 对 nums 进行排序
start := 0 // 遍历起始点
res := make([][]int, 0) // 结果列表（子集列表）
s.backtrack(start, target, &state, &nums, &res)
backtrackSubsetSumII(start, target, &state, &nums, &res)
return res
}
```