Google面试题之100层仍两个棋子

一道Google面试题，题目如下：“有一个100层高的大厦，你手中有两个相同的玻璃围棋子。从这个大厦的某一层扔下围棋子就会碎，用你手中的这两个玻璃围棋子，找出一个最优的策略，来得知那个临界层面。“

版本一：

　　为了得到两个棋子的最优策略，我们先简化问题，看看一个棋子的情况。如果手中只有一个棋子，为了得知临界层面，你只有一种选择：从2楼开始，一层一层地试，直到棋子被打碎，此时你站的楼层就是所求的临界层面。在最差的情况下，我们需要投掷99-2+1=98次，你可能奇怪为什么不是100-2+1=99次，那是因为题目已经告诉我们“从这个大厦的某一层扔下围棋子就会碎”，所以在99层扔下来还没碎的话就不用去100层了——从那里扔它一定会碎。

　　从一个棋子的策略我们可以看出，一个棋子就足以解答这个问题了。现在又多了一个棋子，该如何利用它呢？很自然地，我们希望能通过这个棋子缩小这种一层一层查找的范围。为了缩小范围，我们将整个大厦的层数分成x段，在这x段中查找那个临界段，然后在临界段中再一层一层地找临界层。比如可以将大楼分成4段，我们分别在25层、50层、75层投掷棋子，以确定临界段；如果临界段在25层到50层，我们再从26层开始一层一层查找临界层。

　　分析到这里，问题就转化成了如何确定分段数x使棋子投掷的次数最少的问题。在最差的情况下，要确定临界段，我们需要投掷100/x-1次；确定了临界段之后要确定临界层，我们需要再投掷x-1次。因此，问题就成了求函数f(x)=(100/x-1)+(x-1)的最小值问题。先对f(x)求导，f’(x)=1-100/x²，令f’(x)=0求出驻点x=10(x=-10舍去)。由于f(x)存在最小值且只有一个驻点，所以当x=10时f(x)取得最小值，最小值为18。这样就解答了这个问题。（不等式就可以求了）

　　其实10这个结果也很容易直接看出来。在只有一个棋子时，我们相当于把整个大厦分成了一段，这一段有100层。在有两个棋子时，我们有很多分法，但无论怎么分，如果分成k₁段，每段有k₂层，那么就有k₁k₂=100。在最坏的情况下，我们需要投掷(k₁-1)+(k₂-1)次。因此问题也可以表述成在k₁k₂=100的条件约束下，如何让函数f(k₁,k₂)=
k₁+k₂最小。在初等数学中，我们知道在矩形面积一定的情况下，正方形的周长最小。利用这个结论，我们可以直接得出结论k₁=k₂=10。

　　现在问题已经完满解决，但我还想把这个问题扩展一下，把它变成“m层楼n个棋子”的情况。首先来看这样一个问题，给定m层楼，多少个棋子就“足够”了，也就是说，再多的棋子也不能加快查找的过程。在我所能想到的方法里，二分法应该是最优的，如果按二分法来查找，则需要ceiling(log₂m)个棋子（ceiling是向上取整函数），超过这个数再多的棋子也无益。

　　如果n>=ceiling(log₂m)，那就采用二分法，现在考虑n<
ceiling(log₂m)的情况。前面已经看到，当n=2时，问题可以表述成在k₁k₂=100的条件约束下，求函数f(k₁,k₂)= k₁+k₂的最小值。类似地，在n个棋子的情况下，问题可以表述成在k₁k₂…k_n=m的条件约束下，求函数f(k₁,k₂,…,k_n)=k₁+k₂+…+k_n的最小值。利用拉格朗日乘数法，我们可以很容易地求出：当k₁=k₂=…=k_n=ⁿ√m时，这个多元函数取得最值。ⁿ√m有可能不是整数，因此这只是一个理论上的结果。

　　我们换一个思路考虑，m层楼n个棋子的问题其实就是如何将m分解成n个因子相乘，从而让各个因子之和最小。如何分解m使得策略最优就成了问题的关键。前面得出的结论提示我们尽量让各个因子相等或者相差较小，它们相加的结果才会较小。比如，100层楼3个棋子的情况，5，5，4应该是一个最优的选择。

　　考虑到这里，又有一个问题出现了：是不是将m分解的越多越好呢？比如，将100分解成10，10好呢，还是2，5，10好？这个问题其实就是在问，两个大于1的整数，它们的和大呢还是积大。很明显，当然是积大，因此将m分解的越多越好。

　　数论告诉我们，质数是整数的基础，所有整数都可以分解成若干个质数的乘积。因此，如果将上面的方法发挥到极致，那就要求我们把m分解成质数的乘积。当然，如果棋子足够多，这并不是最优的方法，对质数层楼的段，你仍然可以采用二分法。

------------------------------------------------------------------------------------------------------

　　上文贴出之后，我又在CSDN和ChinaUnix的论坛看了一些网友的解法，发现上述方法并非最优。将大楼分段以缩小查找范围的想法是没错的，问题在于是否应该均匀分段。

　　题目要求我们总的投掷次数要最少。在分段之后，总的投掷次数就等于确定临近段的次数加上确定临界层的次数。如果我们均匀分段，则确定临界层的最坏投掷数是固 定的（9次），随着我们确定临近段的投掷次数增加，总的投掷次数也在增加。这样一来，随着临界段的不同，投掷次数也不同。

　　这也就是为什么上述方法不是最优的原因：投掷次数分布不均。按最坏情况估计，这种方法就多做了几次。为了使最坏情况的投掷数最小，我们希望无论临界段在哪里，总的投掷数都不变，也就是说将投掷数均匀分布。

　　接下来的解决方案就很容易想出了：既然第一步（确定临界段）的投掷数增加不可避免，我们就让第二步（确定临界层）的投掷数随着第一步的次数增加而减少。第一步的投掷数是一次一次增加的，那就让第二步的投掷数一次一次减少。假设第一次投掷的层数是f，转化成数学模型，就是要求f+(f-1)+...+2+1>=99，即f(f+1)/2>=99，解出结果等于14。

　　这种方法要推广到n（n>2）个棋子的情况比较困难。我初步的想法是，先用均匀分段求出一个解，然后修正这个解使投掷次数均匀分布。如果你对此有兴趣，不妨思考一下具体的解法。

版本二：

　　如果是两个玻璃球，最少次数m确定楼高为N的哪一层开始能使这个玻璃球摔碎这个问题，等价于求最小的m，使得 1+2+...+m >= N 。

假设N正好等于1+2+...+m，那么我觉得最有的策略就是第一个玻璃球扔在第m层，如果碎了，显然需要剩下的m-1层从底往上一一尝试，最坏情况就是m；假设m处没有碎，问题等价于楼高N'=1+2+...+(m-1)的地方同样的问题需要的次数m'+1 （1就是第一次在m层的尝试），根据我们的递归，容易得到N'对应需要的次数正好是m-1次，因此总次数也是m。

　　我们的二分应该倾向于不管失败还是成功，两种情况的总检测次数相等。因此这应该是最优的算法。

　　当然，当N不能表示成1+2+...+m使，我们只能找最小的m作为需要测试的次数。

　　至于100层楼，显然m=14，我们的第一次扔球应该分别在第14, 如果没碎继续在14+13=27，再没有碎则扔在第27＋12＝39层，以此类推。最坏需要14次判断。

版本三：

题目的意思应该是

找出一个固定的方案A, 使得对于目标t为任意[1,100]里的数的时候, 找出t要扔的最多的次数 最小

因为t不同的时候, 方案A要扔的次数不一定一样, 我们就是要使得这个最多的次数最小

动态规划就好了

F(l,r,k)为 确定目标t是否在[l,r]中且手上有k个棋子的最少扔子次数, 有状态转移方程:
             /      (r-l+1)             (k = 1)
F(l,r,k) =   |      1                   (l = r)
             |      0                   (l > r)
             \      1+min{max{F(l,mid-1,k-1),F(mid+1,r,k)}}    (l<=mid<=r)

写了程序算了一下，是14

#include "stdio.h"
#include "string.h"

const int INF = 200000000;
const int maxN = 110;

int f[maxN][maxN][maxN];
int n, k;

int
find(int l, int r, int k)
{
        if (l > r)
        {
                return 0;
        }
        if (k == 1)
        {
                return r - l + 1;
        }
        if (l == r)
        {
                return 1;
        }
        if (f[l][r][k] != -1)
        {
                return f[l][r][k];
        }
        int mid;
        int left, right, t;
        f[l][r][k] = INF;
        for (mid = l; mid <= r; ++mid)
        {
                left = find(l, mid - 1, k - 1);
                right = find(mid + 1, r, k);
                t = left > right ? left : right;
                f[l][r][k] <?= t;
        }
        return ++f[l][r][k];
}

int
main()
{
        memset(f, -1, sizeof(f));
        while (scanf("%d %d", &n, &k) == 2)
        {
                printf("%d\n", find(1, n, k));
        }
        return 0;
}