给定一个非负数组arr，和一个正数m。 返回arr的所有子序列中累加和%m之后的最大值。
自然智慧即可。
1.递归，累加和。
2.动态规划，累加和。
3.动态规划，累加和%m。
4.双向动态规划，累加和%m。
代码用golang编写。代码如下：
package main
import (
"fmt"
"math/rand"
"sort"
"time"
)
func main() {
rand.Seed(time.Now().Unix())
const TOTAL = 500
RightCount := 0
for i := 0; i < TOTAL; i++ {
arr := NewRandArr()
m := rand.Intn(200) + 1
fmt.Println(arr, m)
ret1 := max1(arr, m)
fmt.Println("1.递归,累加和：", ret1)
ret2 := max2(arr, m)
fmt.Println("2.动态规划，累加和：", ret2)
ret3 := max3(arr, m)
fmt.Println("3.动态规划，累加和%m：", ret3)
ret4 := max4(arr, m)
fmt.Println("4.双向动态规划，累加和%m：", ret4)
fmt.Println("---------------------")
if ret1 == ret2 && ret1 == ret3 && ret1 == ret4 {
RightCount++
}
}
fmt.Println("总数：", TOTAL)
fmt.Println("正确：", RightCount)
}
//递归，算出所有子序列的累加和
func max1(arr []int, m int) int {
set := make(map[int]struct{})
process(arr, 0, 0, set)
max := 0
for sum, _ := range set {
max = getMax(max, sum%m)
}
return max
}
func process(arr []int, index int, sum int, set map[int]struct{}) {
if index == len(arr) {
set[sum] = struct{}{}
} else {
process(arr, index+1, sum, set)
process(arr, index+1, sum+arr[index], set)
}
}
func getMax(a int, b int) int {
if a > b {
return a
} else {
return b
}
}
//2.动态规划，算出所有的累加和
func max2(arr []int, m int) int {
sum := 0
N := len(arr)
for i := 0; i < N; i++ {
sum += arr[i]
}
dp := make([][]bool, N)
for i := 0; i < N; i++ {
dp[i] = make([]bool, sum+1)
}
for i := 0; i < N; i++ {
dp[i][0] = true
}
dp[0][arr[0]] = true
for i := 1; i < N; i++ {
for j := 1; j <= sum; j++ {
dp[i][j] = dp[i-1][j]
if j-arr[i] >= 0 {
dp[i][j] = dp[i][j] || dp[i-1][j-arr[i]]
}
}
}
ans := 0
for j := 0; j <= sum; j++ {
if dp[N-1][j] {
ans = getMax(ans, j%m)
}
}
return ans
}
//3.动态规划，算出所有的模m的累加和。数组长度巨大，m不大。
func max3(arr []int, m int) int {
N := len(arr)
// 0...m-1
dp := make([][]bool, N)
for i := 0; i < N; i++ {
dp[i] = make([]bool, m)
}
for i := 0; i < N; i++ {
dp[i][0] = true
}
dp[0][arr[0]%m] = true
for i := 1; i < N; i++ {
for j := 1; j < m; j++ {
// dp[i][j] T or F
dp[i][j] = dp[i-1][j]
cur := arr[i] % m
if cur <= j {
dp[i][j] = dp[i][j] || dp[i-1][j-cur]
} else {
dp[i][j] = dp[i][j] || dp[i-1][m+j-cur]
}
}
}
ans := 0
for i := 0; i < m; i++ {
if dp[N-1][i] {
ans = i
}
}
return ans
}
// 如果arr的累加和很大，m也很大
// 但是arr的长度相对不大
func max4(arr []int, m int) int {
if len(arr) == 1 {
return arr[0] % m
}
mid := (len(arr) - 1) / 2
sortSet1 := make(map[int]struct{})
process4(arr, 0, 0, mid, m, sortSet1)
sortSet2 := make(map[int]struct{})
process4(arr, mid+1, 0, len(arr)-1, m, sortSet2)
ans := 0
s1 := make([]int, 0)
for key, _ := range sortSet1 {
s1 = append(s1, key)
}
sort.Ints(s1)
//fmt.Println("s1:", s1)
s2 := make([]int, 0)
for key, _ := range sortSet2 {
s2 = append(s2, key)
}
sort.Ints(s2)
//fmt.Println("s2:", s2)
for _, leftMod := range s1 {
//ans = getMax(ans, leftMod + sortSet2.floor(m - 1 - leftMod));
index := NearestIndex2(s2, m-1-leftMod)
if index >= 0 {
ans = getMax(ans, leftMod+s2[index])
} else {
ans = getMax(ans, leftMod)
}
}
return ans
}
// 在arr上，找满足<=value的最右位置
func NearestIndex2(arr []int, v int) int {
L := 0
R := len(arr) - 1
index := -1 // 记录最右的对号
for L <= R {
mid := L + (R-L)>>1
if arr[mid] <= v {
index = mid
L = mid + 1
} else {
R = mid - 1
}
}
return index
}
// 从index出发，最后有边界是end+1，arr[index...end]
func process4(arr []int, index int, sum int, end int, m int, sortSet map[int]struct{}) {
if index == end+1 {
sortSet[sum%m] = struct {
}{}
} else {
process4(arr, index+1, sum, end, m, sortSet)
process4(arr, index+1, sum+arr[index], end, m, sortSet)
}
}
func NewRandArr() []int {
arrLen := rand.Intn(10) + 5
arr := make([]int, arrLen)
for i := 0; i < arrLen; i++ {
arr[i] = rand.Intn(50)
}
return arr
}执行结果如下：
