丢棋子问题

丢棋子问题

题目描述

一座大楼有$0\sim N$层，地面算作第0层，最高的一层为第N层。已知棋子从第0层掉落肯定不会摔碎，从第i层掉落可能会摔碎，也可能不会摔碎($1⩽i⩽N$)。给定整数N作为楼层数，再给定整数K作为棋子数，返回如果想找到棋子不会摔碎的最高层数，即使在最差的情况下扔的最小次数。一次只能扔一个棋子。

[要求]

时间复杂度在最坏情况下为$O(n)$

输入描述：

输入两个数N, K

输出描述：

输出一个数表示答案。

示例1

输入

10 1

输出

10

说明

因为只有1棵棋子，所以不得不从第1层开始一直试到第10层，在最差的情况下，即第10层是不会摔坏的最高层，最少也要扔10次

示例2

输入

3 2

输出

2

说明

先在2层扔1棵棋子，如果碎了，试第1层，如果没碎，试第3层

示例3

输入

105 2

输出

14

说明

第一个棋子先在14层扔，碎了则用仅存的一个棋子试1~13层
若没碎，第一个棋子继续在27层扔，碎了则用仅存的一个棋子试15~26层
若没碎，第一个棋子继续在39层扔，碎了则用仅存的一个棋子试28~38层
若没碎，第一个棋子继续在50层扔，碎了则用仅存的一个棋子试40~49层
若没碎，第一个棋子继续在60层扔，碎了则用仅存的一个棋子试51~59层
若没碎，第一个棋子继续在69层扔，碎了则用仅存的一个棋子试61~68层
若没碎，第一个棋子继续在77层扔，碎了则用仅存的一个棋子试70~76层
若没碎，第一个棋子继续在84层扔，碎了则用仅存的一个棋子试78~83层
若没碎，第一个棋子继续在90层扔，碎了则用仅存的一个棋子试85~89层
若没碎，第一个棋子继续在95层扔，碎了则用仅存的一个棋子试91~94层
若没碎，第一个棋子继续在99层扔，碎了则用仅存的一个棋子试96~98层
若没碎，第一个棋子继续在102层扔，碎了则用仅存的一个棋子试100、101层
若没碎，第一个棋子继续在104层扔，碎了则用仅存的一个棋子试103层
若没碎，第一个棋子继续在105层扔，若到这一步还没碎，那么105便是结果

备注：

$1⩽N,K⩽10^6$
保证最后答案在long long范围内

---

解法一：

递归，设 F(n, k) 表示 n 层楼有 k 个棋子在最差情况下扔的最少次数。

1. 若 n == 0 ，则 F(0, k) = 0 ；

2. 若 k == 1 ，也就是有 n 层楼，只有一个棋子，只能从第一层开始一层一层的尝试，则 F(n, 1) = n；

3. 对于一般情况，我们需要考虑第 1 个棋子需要先从哪层开始扔，假设从第 i 层开始扔：

   1）若碎了，那么没有必要尝试第 i 层以上的楼层，所以变成了 i-1 层楼，k-1 个棋子，总步数为 1 + F(i-1, k-1)；

   2） 若没碎，那么没有必要尝试第 i 层以下的楼层，所以变成了 n-i 层楼，k 个棋子，总步数为 1 + F(n-i, k)；

   根据题意，在 1）和 2）中哪个是最差的，应该返回哪个。

时间复杂度为 $O(n!)$。

解法二：

动态规划，将法一中的递归转化为二维动态规划，减少重复状态计算（也可以对法一进行记忆化搜索，同样的道理）。

$f[0][k]=0$，$f[n][1]=n$， f [ n ] [ k ] = m i n { m a x { f [ i − 1 ] [ k − 1 ] , f [ n − i ] [ k ] } ( 1 ⩽ i ⩽ n ) } + 1 f[n][k]=min\{ max \{ f[i-1][k-1], f[n-i][k] \}(1 \leqslant i \leqslant n) \} + 1 f[n][k]=min{max{f[i−1][k−1],f[n−i][k]}(1⩽i⩽n)}+1

时间复杂度 $O(n^2\times k)$

解法三：

法二中的动态规划，可以使用滚动数组优化，不过只是优化了空间，时间复杂度还是不变。。。

解法四：

四边形不等式优化。太菜了，看不懂这个。。。时间复杂度为$O(n^2)$

解法五（最优解）：

反过来思考 k 个棋子扔 m 次，最多可以扔多少层楼。打表可以发现：

可以发现：$f[i][j]=f[i][j-1]+f[i-1][j-1]+1$ ，且数据增加的非常快，所以可以考虑使用这个表来求解。

并且 n 层楼完全用二分的方式扔 $\log n+1$ 次就可以确定哪层楼是会碎的最低楼层，所以当棋子数大于 $\log n+1$ 时，直接返回 $\log n+1$ 。

法五代码：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e6;
int f[N];

int log2( int x ) {
    int ret = -1;
    while ( x ) {
        ++ret;
        x >>= 1;
    }
    return ret;
}

int solve(int n, int k) {
    int log2times = log2( n ) + 1;
    if ( k >= log2times ) return log2times;
    int ret = 0;
    int tmp, pre;
    while ( true ) {
        ++ret;
        pre = 0;
        for ( int i = 0; i < k; ++i ) {
            tmp = f[i];
            f[i] += pre + 1;
            if ( f[i] >= n ) return ret;
            pre = tmp;
        }
    }
    return -1;
}

int main(void) {
    int n, k;
    scanf("%d%d", &n, &k);
    printf("%d\n", solve(n, k));
    return 0;
}