x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。 各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。

x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。

如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。 特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。 如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

为了减少测试次数，从每个厂家抽样3部手机参加测试。

如果已知了测试塔的高度，并且采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？

输入数据，一个整数n（3<n<10000）,表示测试塔的高度。 输出一个整数，表示最多测试多少次。

例如： 输入： 3

程序应该输出： 2

解释： 手机a从2楼扔下去，坏了，就把b手机从1楼扔；否则a手机继续3层扔下

再例如： 输入： 7

程序应该输出： 3

解释： a手机从4层扔，坏了，则下面有3层，b,c 两部手机2次足可以测出指数； 若是没坏，手机充足，上面5,6,7 三层2次也容易测出。

资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 不要使用package语句。不要使用jdk1.7及以上版本的特性。 主类的名字必须是：Main，否则按无效代码处理。

---

笨笨有话说： 我觉得3个手机太难了，要是2个手机还可以考虑一下。

歪歪有话说： 想什么呢，你！要是1部手机还用你编程啊？那样的话只好从下往上一层一层测。

递归

public class Main {

	public static void main(String[] args) {
		System.out.println(f(3, 1000));
	}

	// x手机数，y楼层
	private static int f(int x, int y) {
		int time = 0; // 测试次数
		while (max(x, ++time) < y);
		return time;
	}

	// x个手机time次最多可以测多少层
	private static int max(int x, int time) {
		if (x == 1) {
			// 从第一层开始
			return time;
		}
		if (x >= time) {
			// 二分
			return (int) (Math.pow(2, time) - 1);
		}
		// 手机没坏 max(x, time - 1)+max(x - 1, time - 1)+1
		return max(x, time - 1) + max(x - 1, time - 1) + 1;
	}
}

DP

方法一

java

public class Main {
	public static void main(String[] args) {
		int x =3;
		int n = 1000;
		int[][] dp = new int[x+1][n + 1];
		for (int i = 1; i <= n; i++)
			// 一个手机只能从第一层开始 多少层就需要抛多少次
			dp[1][i] = i;

		for (int i = 2; i <= x; i++) {
			// 从第二层开始计算
			for (int j = 1; j <= n; j++) {
				dp[i][j] = Integer.MAX_VALUE;
				// 取从1-j层开始抛中的最小值
				for (int k = 1; k <= j; k++)
					// dp[i][j - k]手机没坏
					// dp[i - 1][k - 1]手机坏了
					dp[i][j] = Math.min(dp[i][j], 1 + Math.max(dp[i][j - k], dp[i - 1][k - 1]));
			}
		}
		System.out.println(dp[x][n]);
	}
}

python

x = 3
n = 1000
dp = [[0] * (n + 1) for i in range(x + 1)]
for i in range(1, n + 1):
    dp[1][i] = i
for i in range(2, x + 1):
    for j in range(1, n + 1):
        dp[i][j] = min([1 + max(dp[i][j - k], dp[i - 1][k - 1]) for k in range(1, j + 1)])
print(dp[x][n])
# ----------------------------------------------------------------------------------------
x = 3
n = 1000
dp = [[], []]
for i in range(0, n + 1):
    dp[1].append(i)
for i in range(2, x + 1):
    dp.append([0])
    for j in range(1, n + 1):
        dp[i].append(min([1 + max(dp[i][j - k], dp[i - 1][k - 1]) for k in range(1, j + 1)]))
print(dp[x][n])

方法2

java

public class Main {
	public static void main(String[] args) {
		System.out.print(f(3, 1000));

	}

		public static int f(int x, int n) {
			int[][] dp = new int[x + 1][100];
			for (int i = 1; i < 100; i++)
				// 一个手机只能从第一层开始 多少层就需要抛多少次
				dp[1][i] = i;

			int time = 0;// 测试次数
			while (dp[x][time] < n) {
				time++;
				// 手机没坏 dp[i][time - 1]+手机坏了dp[i - 1][time - 1]+1
				for (int i = 2; i <= x; i++)
					dp[i][time] = dp[i][time - 1] + dp[i - 1][time - 1] + 1;
			}
			return time;
		}
	}

python

x = 2
n = 1000
dp = [[0] * 100 for i in range(x + 1)]
for i in range(1, 100):
    dp[1][i] = i
time = 0
while dp[x][time] < n:
    time = time + 1
    for i in range(2, x + 1):
        dp[i][time] = dp[i][time - 1] + dp[i - 1][time - 1] + 1
print(time)

版权所有

许可证：署名-相同方式共享 4.0 国际 (CC-BY-SA-4.0)