1. 线性DP 887. 鸡蛋掉落 (DP+二分)

https://leetcode-cn.com/problems/super-egg-drop/

/*
首先分析1个蛋，1个蛋的话，最坏情况需要N次，每次只能从0 1 2 。。。开始
如果蛋的个数随便用，或者说2的k次方大于等于N楼层高度，则可以利用二分。
如果蛋的个数为2，100层楼
1 。。。 100
比如第一次从10，如果碎了，那么还剩一个蛋，1+10次；如果没有碎，到20层仍。如果碎了，2+10次。如果没碎。。。
所以次数是 11 12 13 14 15 16 17 18 19 ，所以最坏可能19次
所以我们要想办法，确定每次下仍的楼层 p, 0=<p1，p2,p3,p4,p5,p6,p7,p8,p9<=N 使得不管每次的次数比较均匀。即例如
p1+p2+p3+p4+p5+p6+p7+p8+p9 = 100
p2-p1=p1-1
p3-p2=p1-2
....
p1=14 p2=27 p3=39 p4=51 p5=62 p6=72 p7=81 p8=89 p9=96 p10=100
那么如果有k个蛋，那么，d[N][K]就是最坏情况下的最小次数
假设在第p层下仍，蛋碎的话 d[p-1][k-1]为p层，k-1个蛋的最小次数
蛋不碎的话，d[N-p][k] 为N-p层，k个蛋的最小次数
最坏情况就是，d[N][k] = Max(d[p-1][k-],d[N-p][k])+1
最坏情况下最小，就是要找一个合适的p使得 MIN(Max(d[p-1][k-],d[N-p][k]))其中 1=<p<=N
 */

const INT_MAX = int(^uint(0) >> 1)
func superEggDrop(K int, N int) int {
	d := make([][]int,N+1)
	for i:=0;i<=N;i++{
		d[i] = make([]int,K+1)
	}
	
	for i:=0;i<=N;i++{
		d[i][1] = i
		d[i][0] = 0
	}
	for j:=0;j<=K;j++{
		d[0][j] =0
        d[1][j] = 1
	}
    d[0][1] = 0
    d[1][0] = 0
	d[0][0] = 0
	for i:=2;i<=N;i++{
		for j:=2;j<=K;j++{
			m := INT_MAX
			for p:=1;p<=i;p++{
				tmp := MAX(d[p-1][j-1],d[i-p][j])+1
				m = MIN(tmp,m)
			}
			d[i][j] = m
		}
	}
	return d[N][K]
}

func MAX(i,j int) int{
	if i<j{
		return j
	}else{
		return i
	}
}

func MIN(i,j int) int{
	if i<j{
		return i
	}else{
		return j
	}
}

复杂度分析：

时间复杂度： $O(N^2K)O(N2K)，三层 for 循环，每层循环都是线性的；$
空间复杂度：