鸡蛋掉落-两枚鸡蛋(从记忆化搜索到动态规划)

 题目

给你 2 枚相同 的鸡蛋,和一栋从第 1 层到第 n 层共有 n 层楼的建筑。

已知存在楼层 f ,满足 0 <= f <= n ,任何从 高于 f 的楼层落下的鸡蛋都 会碎 ,从 f 楼层或比它低 的楼层落下的鸡蛋都 不会碎 

每次操作,你可以取一枚 没有碎 的鸡蛋并把它从任一楼层 x 扔下(满足 1 <= x <= n)。如果鸡蛋碎了,你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎,则可以在之后的操作中 重复使用 这枚鸡蛋。

请你计算并返回要确定 f 确切的值 的 最小操作次数 是多少?

示例 1:

输入:n = 2
输出:2
解释:我们可以将第一枚鸡蛋从 1 楼扔下,然后将第二枚从 2 楼扔下。
如果第一枚鸡蛋碎了,可知 f = 0;
如果第二枚鸡蛋碎了,但第一枚没碎,可知 f = 1;
否则,当两个鸡蛋都没碎时,可知 f = 2。

示例 2:

输入:n = 100
输出:14
解释:
一种最优的策略是:
- 将第一枚鸡蛋从 9 楼扔下。如果碎了,那么 f 在 0 和 8 之间。将第二枚从 1 楼扔下,然后每扔一次上一层楼,在 8 次内找到 f 。总操作次数 = 1 + 8 = 9 。
- 如果第一枚鸡蛋没有碎,那么再把第一枚鸡蛋从 22 层扔下。如果碎了,那么 f 在 9 和 21 之间。将第二枚鸡蛋从 10 楼扔下,然后每扔一次上一层楼,在 12 次内找到 f 。总操作次数 = 2 + 12 = 14 。
- 如果第一枚鸡蛋没有再次碎掉,则按照类似的方法从 34, 45, 55, 64, 72, 79, 85, 90, 94, 97, 99 和 100 楼分别扔下第一枚鸡蛋。
不管结果如何,最多需要扔 14 次来确定 f 

(题目来自Leetcode 1884  鸡蛋掉落-两枚鸡蛋. - 力扣(LeetCode))

解题分析

思路

我们创建一个数组dp[ i ],表示当有 i 层楼时所需的最小操作数。

假设我们在第 j 层扔下第一颗鸡蛋,(其中1<=j<=i)此时将会出现两种情况:鸡蛋碎 / 鸡蛋没有碎。接下来我们分别分析这两种情况:

若鸡蛋碎,则所求楼层 f 在1~i - 1层。由于仅剩一枚鸡蛋,为确保我们能找到 f,我们必须从最低层(第 1 层)开始扔。最坏的情况是,假设所求 f 层在第 i-1 层,那么我们便要操作 i-1 次(按序把1~i-1层都仍一次),加上我们最先扔的第一颗鸡蛋,扔 i 次能保证我们一定能找出 f 层

若鸡蛋没有碎,则所求楼层 f 在 j + 1~ i 层。此时我们仍有两颗鸡蛋。重点来了:从 j + 1~ i 层一共有 i - j 层,我们可以把找出第 j + 1~ i 层中的 f 层的问题,转化成当有 i - j 层楼时所需的最小操作数。回顾我们dp数组的定义,我们便能发现当有 i - j 层楼时的最小操作数位 dp[ i - j ]。在dp[ i - j]的基础上加上第一次扔鸡蛋,我们仅需要 dp[ i - j ] +1次操作,就能保证我们一定能找出 f 层。

分析完两种可能,我们便能求出当有i层时,在第j层扔下第一颗鸡蛋,需要多少次操作才能找到 f 。综合考虑两种情况,由于 我们要保证一定能找到 f 层,所有我们要取两种情况的最大值,也就是max(i,dp[i-j]+1)。我们把它设为x。

当仅有 i 层时,在不同楼层扔下第一颗鸡蛋,所得到的操作数也有所不同。此时我们需要遍历楼层 j ,找到保证得出答案的情况下操作数最小的情况。

得出:dp[ i ] = min ( max( i , dp[ i - j ] +1), dp[ i ] );

dp数组的初始化

dp[0] = 0;

dp[ 其他 ] = INT_MAX;

返回值

dp[ n ]

Coding

1.记忆化搜索

class Solution {
public:
    int dp[1001];    
    int twoEggDrop(int n) {

        if(n==0)return 0;  ///有0层楼时,操作数为0
        if(dp[n])return dp[n];   ///有n层楼时,若dp已记录了此时的最小操作数,直接返回

        dp[n]=INT_MAX;
        for(int i=1;i<=n;i++){    ///若dp[ n ]未被记录,计算dp [ n ]
            int x=max(i,1+twoEggDrop(n-i));
            dp[n]=min(dp[n],x);
        }
        return dp[n];
    }
};

鸡蛋掉落-两枚鸡蛋(从记忆化搜索到动态规划)_第1张图片

2.动态规划

动态规划就是记忆化搜索的改良。将递归改为循环,将函数改为数组。

class Solution {
public:
    int twoEggDrop(int n) {
        vectordp(n+1,INT_MAX);
        dp[0]=0;
        for(int i=1;i<=n;i++){   ///i表示有i层楼
            for(int j=1;j<=i;j++){   ///j表示第一颗鸡蛋在第j层落下
                int temp=max(j,1+dp[i-j]);
                dp[i]=min(dp[i],temp);
            }
        }
       return dp[n];
    }
};

鸡蛋掉落-两枚鸡蛋(从记忆化搜索到动态规划)_第2张图片

3.其他方法:数学方法

通过官解给的样例(2)找规律。

“9,22, 34, 45, 55, 64, 72, 79, 85, 90, 94, 97, 99 和 100 楼分别扔下第一枚鸡蛋。”

34, 45, 55, 64, 72, 79, 85, 90, 94, 97, 99 和 100中,

100-99=1

99-97=2

97-94=3

……

22-9=13

那么9前应该是9-14=-5,这层楼显然不存在,作为循环结束的标志。

于是我们找到规律。

class Solution {
public:
    int twoEggDrop(int n) {
        if(n==1)return 1;
        int cnt=0;
        int x=1;
        do{
            cnt++;
            n-=x;
            x++;
        }while(n>0);
        return cnt;
    }
};

鸡蛋掉落-两枚鸡蛋(从记忆化搜索到动态规划)_第3张图片

你可能感兴趣的:(数据结构与算法,动态规划,算法)