鸡蛋掉落问题----动态规划

leetcode第887题鸡蛋掉落

题目描述：

你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N  共有 N 层楼的建筑。每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。你的目标是确切地知道 F 的值是多少。无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？

思路1：

这个题的问题是：如何在最小的移动次数内确定鸡蛋可以掉碎的最低楼层？很明显这是一个最优化问题，也就是求f(K,N)的最小值。既然时求最优解，我们就可以考虑使用动态规划的方法来解。将情况分为以下几种：

1、楼层数为0或者鸡蛋数为0，那最少的移动次数就是0。f(0,N)=0,f(K,0)=0

2、鸡蛋数为1，那就需要从第一层开始逐步向上扔，所以最少的移动次数为楼层数。f(1,N)=N

3、当楼层数大于0且鸡蛋数大于1，假设有K个鸡蛋，N层楼，我们首先从X层将鸡蛋扔下，这是会有两种情况：

（1）鸡蛋碎了：那我们就排除了x层之上包括x的楼层，同时损失了一枚鸡蛋。所以有1+f(K-1，X-1).

（2）鸡蛋没碎：那我们就排除了x层之下包括x的楼层，并且没有损失鸡蛋。所以有1+f(K,N-X).需要在这两个值中选取较大的值（最坏的情况）。

而且题目要求：无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？这很明显了x有关系，如果x取得好，那移动的次数就会少。所以需要使用穷举的办法将x从1-N逐一计算，其中的最小值就是答案。

动态规划状态转化方程：

f(0,N)=0  //没有楼层
f(K,0)=0  //没有鸡蛋
f(1,N)=N  //只有一个鸡蛋
f(K,N)=min(1+max(f(k-1,x-1),f(k,N-x))) //x=1,2,3....

代码实现：

#include <iostream>
#include <vector>
using namespace std;
int maxStop(int x, int y)
{
	return x <= y ? y : x;
}
int moveStop(int floor, int eggs)
{
	//保证数据可已存储下
        //静态数组，一旦数据过大就会报Stackoverflow，可以考虑将数组申请为动态
	vector<vector<int>> dp;
	dp.resize(floor + 1, vector<int>(eggs + 1));
	//只有1个鸡蛋，移动步数为楼层数
	for (int i = 0; i <= floor; ++i)
	{
		dp[i][1] = i;
	}
	for (int i = 1; i <= floor; ++i)
	{
		//1个鸡蛋已经计算过，所以从2个鸡蛋开始计算。
		for (int j = 2; j <= eggs; ++j)
		{
			int min = INT_MAX;
			int max;
			//计算最优的起始楼层
			for (int k = 1; k <= i; ++k)
			{
				max = 1 + maxStop(dp[k - 1][j - 1], dp[i - k][j]);
				if (min>max)
				{
					min = max;
				}
			}
			dp[i][j] = min;
		}
	}
	return dp[floor][eggs];
}

int main()
{
	int floor, eggs;
	cout << "楼层数，鸡蛋数:";
	cin >> floor >> eggs;
	while (1)
	{
		cout << moveStop(floor, eggs) << endl;;
		cout << "楼层数，鸡蛋数:";
		cin >> floor >> eggs;
	}
	return 0;
}

这个算法的时间复杂度过高O(M*M*N)，O(M*N)。一旦数据过大，计算就会非常大。

优化：

时间复杂度是由，状态转化方程决定的，在不改变状态转化方程的前提下是没有办法降低的，但空间复杂度是可以降低的。因为，鸡蛋数只和当前鸡蛋数和上一层鸡蛋数有关系，所以可以将，空间复杂度降为O(2*N).Leetcode提交不过。

思路2：

将问题转化为K个鸡蛋在m步可以确定的最大楼层数。就是求f(K,m)<=N的最小值。

和上一次的思路的一样，我们从X楼开始扔，还是有两种情况：

（1）鸡蛋碎了：那么步数和鸡蛋数减1，所以只能向下寻找f(K-1,m-1)

（2）鸡蛋没碎:那么步数减1，鸡蛋数没有变，所以可以向上寻找f(K,m-1).

动态规划状态转化方程：

f(0,m)=0 //没有鸡蛋无法测试
f(K,0)=0 //没有步数无法测试
f(1,m)=m //只有一个鸡蛋可以测试m层
f(K,m)=f(K,m-1)+f(K-1,m-1)+1 //向上寻找的层数+向下寻找的层数+本层

代码：

#include <iostream>
#include <vector>
using namespace std;
int maxFloor(int eggs, int step)
{
	vector<vector<int>> dp;
	dp.resize(eggs+1, vector<int>(step+1));
	for (int i = 0; i <= step; ++i)
	{
		//只有1个鸡蛋
		dp[1][i] = i;
	}
	for (int i = 2; i <= eggs; ++i)
	{
		for (int j = 1; j <= step; ++j)
		{
			dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] + 1;
			if (dp[eggs][j] >= step)
			{
				return j;
			}
		}
	}
	//最小可以确定step层
	return step;
}
int main()
{
	int eggs, step;
	cin >> eggs >> step;
	cout << maxFloor(eggs, step);
	return 0;
}