动态规划——范围上的尝试模型

/*
范围上尝试的模型

一开始所有牌都能被彼此看见
给定一个整型数组arr,代表数值不同的纸牌排成一条线，
玩家A和玩家B依次拿走每张纸牌，
规定玩家A先拿，玩家B后拿，
但是每个玩家每次只能拿走最左或最右的纸牌，
玩家A和玩家B都绝顶聪明(博弈论：双方玩家都不会在对方单独改变策略的情况下，让对方得到收益)。请返回最后获胜者的分数

 70   100  1  4
 A 70 4 100暴露给B  4
 B 70  1
 A 100 + 4


该题不是取石子问题
取石子是四边形不等式问题，属于动态规划
*/



func win1(arr []int) int {
	if arr == nil || len(arr) == 0 {
		return 0
	}
	return Max(first(arr,0,len(arr)-1),second(arr,0,len(arr)-1))
}

//先手
func first(arr []int, L, R int) int {  //L, R 范围上拿走一张牌
	if L == R {
		return arr[L]
	}
	return Max(arr[L]+second(arr,L+1, R),arr[R]+second(arr,L, R-1))
}

//后手
func second(arr []int, L, R int) int {
	if L == R {
		return 0
	}
	return Min(first(arr, L+1, R),first(arr, L, R-1))
}

func Min(a, b int) int {
	if a > b {
		return b
	}
	return  a
}

// L ... R
// F  S L+1...R
//      L  ...R-1
// 数组范围上的尝试
/*

arr [1,7,9,100]
       f
   0  1  2  3    ->R
0  1     v [*]
1  X  7     v
2  X  X  9
3  X  X  X  100

L



       s
   0  1  2  3    ->R
0  0     v [*]
1  X  0     v
2  X  X  0
3  X  X  X  0

L

用f的对角线 推 s的对角线
用s的对角线 推 f的对角线
*/
func winforDp(arr []int) int {
	if arr == nil || len(arr) == 0 {
		return 0
	}
	N := len(arr)
	f := make([][]int,N)
	for k := range f {
		f[k] = make([]int,N)
	}
	s := make([][]int,N)
	for k := range s {
		s[k] = make([]int,N)
	}

	for i := 0; i < N; i++ {
		f[i][i] = arr[i]
	}
	// s[i][i] = 0
	for i := 1; i < N; i++ {
		L := 0
		R := i
		for L < N && R < N {
			f[L][R] = Max(arr[L]+s[L+1][R],arr[R]+s[L][R-1])
			s[L][R] = Min(f[L+1][R],f[L][R-1])
			L++
			R++
		}

	}
	return Max(f[0][N-1],s[0][N-1])
}


func TestWin1(t *testing.T){
	fmt.Println("先手",first([]int{4,7,9,5},0,3))
	fmt.Println("后手",second([]int{4,7,9,5},0,3))
	fmt.Println(win1([]int{4,7,9,5}))
	fmt.Println(winforDp([]int{4,7,9,5}))
}