怪兽存活概率问题

题目描述

给定3个参数,N,M,K 怪兽有 N 滴血,等着英雄来砍自己,英雄每一次打击,都会让怪兽流失,
怪兽每一次流失的血量在区间[0……M]上等概率的获得一个值,求 K 次打击之后,英雄把怪兽砍死的概率。

主要思路

由题目含义可知:怪兽在经历 K 次打击后所有可能的掉血情况有 (M+1) 的 K 次方种,,即:

long all = (long) Math.pow(M + 1, K)

如果怪兽在 K 次打击后,被砍死的情况有 kill 种,那么

(double) kill / (double) all;

即为怪兽被砍死的概率。

暴力解法

定义递归函数

long process(int times, int M, int hp)

递归含义是:怪兽还剩 hp 点血,每次的伤害在[0……M]范围上,还有 times 次可以砍,返回砍死的情况数。

那么 base case 有如下两种情况

// 情况一:已经没有被砍的次数了,这个时候,血量如果正好是小于等于0的值, 说明怪兽已经被砍死一次
// 否则怪兽不可被砍死
if (times == 0) {
    return hp <= 0 ? 1 : 0;
}
// 情况二:怪兽已经死了,但是还可以砍
// 此时,所有的砍法都满足条件,所以情况就是(long) Math.pow(M + 1, times)
if (hp <= 0) {
    return (long) Math.pow(M + 1, times);
}

接下来就是普遍情况,由于每次攻击是 [0……M] 中等概率的一个值,则枚举从 0 到 M 任意一个值跑递归函数即可。

long ways = 0;
for (int i = 0; i <= M; i++) {
    ways += process(times - 1, M, hp - i);
}

完整代码如下

public class Code_KillMonster {
    public static double right(int N, int M, int K) {
        if (N < 1 || M < 1 || K < 1) {
            return 0;
        }
        // monster在经历K次打击后所有可能的掉血情况是
        long all = (long) Math.pow(M + 1, K);
        long kill = process(K, M, N);
        return (double) kill / (double) all;
    }

    //怪兽还剩 hp 点血,每次的伤害在[0……M]范围上,还有 times 次可以砍,返回砍死的情况数。
    public static long process(int times, int M, int hp) {
        // 情况一:已经没有被砍的次数了,这个时候,血量如果正好是小于等于0的值, 说明怪兽已经被砍死一次
        // 否则怪兽不可被砍死
        if (times == 0) {
            return hp <= 0 ? 1 : 0;
        }
        // 情况二:怪兽已经死了,但是还可以砍
        // 此时,所有的砍法都满足条件,所以情况就是(long) Math.pow(M + 1, times)
        if (hp <= 0) {
            return (long) Math.pow(M + 1, times);
        }
        long ways = 0;
        for (int i = 0; i <= M; i++) {
            ways += process(times - 1, M, hp - i);
        }
        return ways;
    }
}

动态规划(未做枚举优化)

根据上述暴力递归函数可以得知,递归函数的可变参数有两个,分别是 times 和 hp,且变化范围是固定的,可以定义一个二维数组 dp,表示所有的递归过程解

long[][] dp = new long[K + 1][N + 1];

dp[times][hp] 就表示递归函数long process(int times, int M, int hp)的含义,即:怪兽还剩 hp 点血,每次的伤害在[0……M]范围上,还有 times 次可以砍,砍死的情况数有多少。

根据 base case, 可知

dp[0][0] = 1;

dp[times][0] = (long) Math.pow(M + 1, times)

接下来就是普遍位置,根据上述暴力递归函数可知:process(times, M, hp)依赖process(times - 1, M, hp - i)

dp[times][hp]依赖dp[times-1][hp-i]位置,如下图所示

怪兽存活概率问题-小白菜博客

图中绿色部分的格子依赖黄色部分的格子,

代码如下,

for (int times = 1; times <= K; times++) {
    dp[times][0] = (long) Math.pow(M + 1, times);
    for (int hp = 1; hp <= N; hp++) {
        long ways = 0;
        for (int i = 0; i <= M; i++) {
            if (hp - i >= 0) {
                ways += dp[times - 1][hp - i];
            } else {
                ways += (long) Math.pow(M + 1, times - 1);
            }
        }
        dp[times][hp] = ways;
    }
}

完整代码如下

public class Code_KillMonster {
    public static double dp1(int N, int M, int K) {
        if (N < 1 || M < 1 || K < 1) {
            return 0;
        }
        long all = (long) Math.pow(M + 1, K);
        long[][] dp = new long[K + 1][N + 1];
        dp[0][0] = 1;
        for (int times = 1; times <= K; times++) {
            dp[times][0] = (long) Math.pow(M + 1, times);
            for (int hp = 1; hp <= N; hp++) {
                long ways = 0;
                for (int i = 0; i <= M; i++) {
                    if (hp - i >= 0) {
                        ways += dp[times - 1][hp - i];
                    } else {
                        ways += (long) Math.pow(M + 1, times - 1);
                    }
                }
                dp[times][hp] = ways;
            }
        }
        long kill = dp[K][N];
        return (double) ((double) kill / (double) all);
    }
}

动态规划(枚举优化)

上述动态规划解法中的第三个循环可以优化,再一次看下依赖关系图

怪兽存活概率问题-小白菜博客

当我们得到绿色格子,即dp[times][hp]位置的值以后,如果要求dp[times+1][hp]位置的时候,即如下 target 位置

怪兽存活概率问题-小白菜博客

可以考虑 G 和 H 两个位置

怪兽存活概率问题-小白菜博客

因为 G 位置求的时候,紫色部分格子已经求过了,补上一个 H 位置,就可以把 target 求出来,省略了枚举行为。

完整代码如下

public class Code_KillMonster {
    public static double dp2(int N, int M, int K) {
        if (N < 1 || M < 1 || K < 1) {
            return 0;
        }
        long all = (long) Math.pow(M + 1, K);
        long[][] dp = new long[K + 1][N + 1];
        dp[0][0] = 1;
        for (int times = 1; times <= K; times++) {
            dp[times][0] = (long) Math.pow(M + 1, times);
            for (int hp = 1; hp <= N; hp++) {
                dp[times][hp] = dp[times][hp - 1] + dp[times - 1][hp];
                if (hp - 1 - M >= 0) {
                    dp[times][hp] -= dp[times - 1][hp - 1 - M];
                } else {
                    dp[times][hp] -= Math.pow(M + 1, times - 1);
                }
            }
        }
        long kill = dp[K][N];
        return (double) ((double) kill / (double) all);
    }
}

更多

算法和数据结构笔记