2024-03-06：用go语言，每一种货币都给定面值val[i]，和拥有的数量cnt[i]，
想知道目前拥有的货币，在钱数为1、2、3...m时，能找零成功的钱数有多少？
也就是说当钱数的范围是1~m，返回这个范围上有多少可以找零成功的钱数。
比如只有3元的货币，数量是5张，
m = 10。
那么在1~10范围上，只有钱数是3、6、9时，可以成功找零，
所以返回3，表示有3种钱数可以找零成功。
答案2024-03-06：
# 大体步骤如下：
1.创建一个数组val，存储每种货币的面值，数组cnt存储拥有的每种货币的数量。
2.使用动态规划，创建一个长度为m+1的bool数组dp，dp[i]表示钱数i是否可以找零。
3.初始化dp[0]为true，因为钱数为0时不需要找零，即为成功找零。
4.遍历每种货币，根据面值和数量的不同情况分别处理找零的逻辑。
4.a.如果数量为1，遍历更新dp数组，当j >= val[i]时，如果dp[j-val[i]]为true，则说明钱数j可以成功找零。
4.b.如果数量大于1且面值*数量大于m，遍历更新dp数组，当j >= val[i]时，如果dp[j-val[i]]为true，则说明钱数j可以成功找零。
4.c.如果数量大于1且面值*数量小于等于m，使用更复杂的逻辑更新dp数组，计算出钱数j成功找零的情况。
5.遍历dp数组，计算找零成功的钱数有多少。
6.返回钱数成功找零的总数量。
总的时间复杂度为O(n*m)，其中n为货币种类数，m为钱数范围。
总的额外空间复杂度为O(m)，主要是dp数组的空间。
# go完整代码如下：
```go
package main
import (
"fmt"
)
const MAXN = 101
const MAXM = 100001
var val [MAXN]int
var cnt [MAXN]int
var dp [MAXM]bool
var n, m int
func main() {
inputs := []int{3, 10,
1, 2, 4, 2, 1, 1,
2, 5,
1, 4, 2, 1,
0, 0}
ii := 0
for ii < len(inputs) {
n = inputs[ii]
ii++
m = inputs[ii]
ii++
if n != 0 || m != 0 {
for i := 1; i <= n; i++ {
val[i] = inputs[ii]
ii++
}
for i := 1; i <= n; i++ {
cnt[i] = inputs[ii]
ii++
}
ans := compute()
fmt.Println(ans)
} else {
break
}
}
}
func compute() int {
for i := 1; i <= m; i++ {
dp[i] = false
}
dp[0] = true
for i := 1; i <= n; i++ {
if cnt[i] == 1 {
for j := m; j >= val[i]; j-- {
if dp[j-val[i]] {
dp[j] = true
}
}
} else if val[i]*cnt[i] > m {
for j := val[i]; j <= m; j++ {
if dp[j-val[i]] {
dp[j] = true
}
}
} else {
for mod := 0; mod < val[i]; mod++ {
trueCnt := 0
for j, size := m-mod, 0; j >= 0 && size <= cnt[i]; j -= val[i] {
trueCnt += boolToInt(dp[j])
size++
}
for j, l := m-mod, m-mod-val[i]*(cnt[i]+1); j >= 1; j -= val[i] {
if dp[j] {
trueCnt--
} else {
if trueCnt != 0 {
dp[j] = true
}
}
if l >= 0 {
trueCnt += boolToInt(dp[l])
}
l -= val[i]
}
}
}
}
ans := 0
for i := 1; i <= m; i++ {
if dp[i] {
ans++
}
}
return ans
}
func boolToInt(b bool) int {
if b {
return 1
}
return 0
}
```
