鸡蛋掉落

LeetCode算法网站算法题

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

地位:经典的动态规划算法题

 

鸡蛋数量的理解:

如果只有一个鸡蛋:那么只能一个一个的往上尝试,因为碎了就不能使用了

如果有无数个鸡蛋,那么就可以用二分法,直到分出来的长度小于等于1就找到分界楼层了,如:N层楼就是2^M>=N,M是最少尝试次数。

有限K个鸡蛋,我们就可以用K-1来缩小查找范围,最后一个鸡蛋逐层去尝试。

所以鸡蛋的数量限制了可尝试的次数

如果有两个鸡蛋的话,思路就是第一个每蛋尝试一次,确定范围后,第二个蛋的尝试次数就缩小一点。

x + (x-1) + (x-2) + ... + 1 = N由此我们想到了逆转的思维——由次数构建模型

为什么第一次尝试的层数是X呢?

我们逆转一下思路,假设最少的尝试次数为x,那么我们第一次应该从第几层开始扔,第x层,为什么呢?我们如果从第x-1层开始扔,碎了的话要重新从第一层开始扔,最多需要x-1次;如果从第x+1层开始扔,碎了的话需要x+1次,都与假设不符。

如果第一次扔鸡蛋在第x层,没有碎,那么问题就演化成两个鸡蛋在100-x层楼下往下扔,最少的尝试次数不超过x-1,那么第二次就是在x+x-1层向下扔,以此类推。

正向的思考:

假设在第k层扔鸡蛋,

如果鸡蛋碎了——那么在这一层楼的上方寻找,楼的高度是N-k,鸡蛋的个数是n

如果鸡蛋,没有碎——那么在这一层的下方寻找,楼的高度是k-1,鸡蛋的个数是n-1

这样就找到的递归式子:
 

可以采用动态规划的思想,转换成一个函数 F(N,K)F(N,K)F(N,K),代表的就是最优解的最大尝试次数,假设我们第一个鸡蛋扔出的位置在第x层(1≤x≤N),会出现两种情况:

 

 

第一个鸡蛋没碎,剩下N-x层楼,剩余K个鸡蛋,函数转变为

F(N−x,K)+1,1≤x≤NF(N-x,K) + 1,1≤x≤NF(N−x,K)+1,1≤x≤N

 

 

第一个鸡蛋碎了,剩余x-1层楼,剩余K-1个鸡蛋,函数转变为

F(x−1,K−1)+1,1≤x≤NF(x-1,K-1) + 1,1≤x≤NF(x−1,K−1)+1,1≤x≤N

 

 

整体而言,我们要求出的是 N层楼 / K个鸡蛋 条件下,最大尝试次数最小的解,所以这个题目的状态转移方程式如下:

F(N,K)=min(max(F(N−x,K)+1,F(x−1,K−1)+1)),1<=x<=MF(N,K)= min(max(F(N-x,K)+ 1,F(x-1,K-1)+ 1)),1<=x<=MF(N,K)=min(max(F(N−x,K)+1,F(x−1,K−1)+1)),1<=x<=M

max函数的使用是为了一定找到分界楼层,所以取最大值,取次数最多的情况,客观选择最大值;

min函数的使用是为了找到最合适的方案,每一种方案都可以找到最恶劣的情况,主观选择最低成本;

1.简单的递归——模型找次数

2.动态规划

3.优化dp的空间——由于在上述的dp中,发现我们只是用了两行,所以就使用一个数组表示鸡蛋摔碎的情况,另一个表示鸡蛋没有碎的情况

4.换一种dp的想法——上一种的dp是i表示鸡蛋的数量,j表示楼层的高度(是基于知道鸡蛋的数量,楼的高度去求解所有情况的最小方案)

这次的dp思路是——dp的i表示鸡蛋的数量,j表示扔鸡蛋的次数(是基于知道鸡蛋的数量,和扔鸡蛋的次数求解所能求出所有情况的最高楼层)

 

在回顾一下dp[k][j]的含义, dp[k][j] 代表了 [0,NN]这样一个区间

dp[k][j-1]代表[X,NN] - > [0,NN-X]  -> dp[k][j-1] = NN - X

dp[k-1][j-1] 代表[0,X-1] -> dp[k-1][j-1] = X - 1

但是dp[k][j] = NN = (X - 1) + (NN - X) + 1 = dp[k][j-1] + dp[k-1][j-1] + 1

理解

如果第x次操作碎了,那么就在上方,没碎就在下方,而且剩下的操作是不包括本层的,所以要+1,这是一种根据情况反推模型的思路,dp[k-1][j-1]是碎了的情况,dp[k][j-1]是没有碎的情况,为了一定找到分界楼层,所以上下相加。能得到能检测的最高楼层,含要加上第x操作的楼层。

class Solution {

public:

    int superEggDrop(int K, int N) {

vector<vector<int>> dp(N + 1, vector<int>(K + 1));//二维vector的固定长度声明

int m = 0;

while (dp[m][K] < N) {

++m;

for (int j = 1; j <= K; ++j) {

dp[m][j] = dp[m - 1][j - 1] + dp[m - 1][j] + 1;

}

}

return m;

    }

}

 

第一次看完李永乐老师的视频写的代码 :  

int superEggDrop(int K, int N)

    {

        int i=0,j=0;

        int move_times,f=0;

        int**dp;

        dp=new int*[K+1];

        for(i=0; i<K+1; i++)//一定要注意对0边界的初始化为0,一是为了防止乱码,二是为了逻辑通顺,除非是全局变量,声明时就初始化为0

            dp[i]=new int[N+1];

        for(i=0; i<K+1; i++)

        {

            dp[i][0]=0;

        }

        for(j=0; j<N+1; j++)

        {

            dp[0][j]=0;

        }

        for(i=1; i<K+1; i++)//只有一个鸡蛋时,只能一个一个的放置

            dp[i][1]=1;

        for(j=1; j<N+1; j++)//只有一层楼时,只用尝试一次

            dp[1][j]=j;

        for(i=2; i<K+1; i++)

            for(j=2; j<N+1; j++)

            {

                move_f=INT_MAX;//记得每次循环前都要初始化为最大,否则上一个数的计算会影响这一次的比较

                for(f=1; f<=j; f++)

                {

                    if(move_f>max(dp[i][j-f],dp[i-1][f-1])+1)//记得是f-1,因为不包括已经扔过的那一层

                        move_f=max(dp[i][j-f],dp[i-1][f-1])+1;

                }

                dp[i][j]=move_f;

            }

        return dp[K][N];

    }

 

 

©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页