动态规划——从左往右的尝试模型2

/*
从左往右的尝试模型2  (背包问题)

给定两个长度都为N 的数组weights 和 values，  N个货物 N个价值
weights[i] 和 values[i]分别代表i号物品的重量和价值。
给定一个整数bag，表示一个载重bag的袋子，
你装的物品不能超过这个重量。
返回你能装下最多的价值是多少。
 */

func GetMaxValue(w, v []int,bag int) int {
	return processMaxValue(w,v,0,0,bag)
}

// 不变： w[]  v[] bag
//index... 最大价值
//0... index - 1 上做了货物的选择，使得你已经达到的重量是alreadyW
//返回 -1 认为没有方案，否则认为返回的值是真实价值
func processMaxValue(w, v []int,index, alreadyW,bag int) int {
	if  alreadyW > bag {
		return -1
	}

	if index == len(w) {  //方案有效，index 往后的价值为0
		return 0
	}

	p1     := processMaxValue(w,v,index + 1,alreadyW,bag)  //没有要当前货
	p2Next := processMaxValue(w,v,index + 1,alreadyW +w[index],bag) //要了当前货，后边货的最大价值
	p2     := -1
	if p2Next != -1 {
		p2 = v[index] + p2Next
	}

	return Max(p1,p2)
}

func Max(a, b int) int  {
	if a < b {
		return  b
	}
	return a
}

//-------------------------------
func GetMaxValue2(w, v []int,bag int) int {
  return processMaxValue2(w,v,0,bag)
}


// 只剩下rest的空间了
// index...货物自由选择，但是剩余空间不要小于0
// 返回能够获得的最大价值
func processMaxValue2(w, v []int,index ,rest int) int {
	if rest < 0 {  // base case
		return -1
	}

	// rest >= 0
	if index == len(w) { // base case 2
		return 0
	}

	//有货也有空间
	p1 := processMaxValue2(w,v,index + 1, rest)
	p2 := -1
	p2Next := processMaxValue2(w,v,index+1,rest - w[index])
	if p2Next != -1 {
		p2 = v[index] + p2Next
	}
	return Max(p1,p2)
}

// 背包问题有大量重复问题，可以改动态规划
/*
     w  [2,1,3,5,4]
     v  [a,b,c,d,e]




    0 1  2 3 4 ...       20
0                        [返回0,bag]
1
2
3
4
5
index


    0 1 2 3 4 ...       20
0                        [返回0,bag]
1
2
3
4
5  0 0 0 0 ......      0
index


 */


// 动态规划转移方程就是暴力递归中的决策
func GetMaxValueforDp(w, v []int,bag int) int {
	N := len(w)
	dp := make([][]int,N+1)  //0 ~N
	for k := range dp {
		dp[k] = make([]int,bag + 1) //0~bag
	}

	for index := N - 1; index >= 0; index-- {
		for rest := 0; rest <= bag; rest++ {
			p1  := dp[index+1][rest]  //底层往上层填，可以直接拿来用
			p2  := -1
			if rest - w[index]  >= 0 {
				p2 = v[index] + dp[index+1][rest-w[index]]
			}
			dp[index][rest] = Max(p1,p2)
		}
	}

	return dp[0][bag]
}

func TestGetMaxValue(t *testing.T)  {
	w := []int{3,2,4,7}
	v := []int{5,6,3,19}
	bag := 11
	fmt.Println(GetMaxValue(w,v,bag))
	fmt.Println(GetMaxValue2(w,v,bag))
	fmt.Println(GetMaxValueforDp(w,v,bag))
}