• 【每日一题】掷骰子等于目标和的方法数


    Tag

    动态规划】【数组】


    题目来源

    1155. 掷骰子等于目标和的方法数


    题目解读

    你手里有 n 个一样的骰子,每个骰子都有 k 个面,分别标号 1n。给定三个整数 nktarget,返回这个 n 个骰子正面朝上的数字组成 target 的所有方案数。答案可能很大,返回对 1 e 9 + 7 1e9+7 1e9+7 取模后的值。


    解题思路

    方法一:动态规划

    我们可以使用动态来解决本题。

    状态

    f[i][j] 表示使用 i 个骰子且数字和为 j 的方案数。

    转移关系

    我们可以枚举最后一个骰子的数字,数字的范围在 [1, k],使用 i 个骰子组成的数字和为 j 的方案数为:

    f [ i , j ] = ∑ x = 1 k f [ i − 1 ] [ j − k ] f\left[ i,j \right] =\sum_{x=1}^k{f\left[ i-1 \right] \left[ j-k \right]} f[i,j]=x=1kf[i1][jk]

    base case

    f[0][0] = 1,计即我们还没有掷骰子,数字之和为 0 时的方案数。

    最终返回

    最终返回 f[n][target],表示使用 n 个骰子正面朝上的数字组成 target 的所有方案数

    实现代码

    class Solution {
    public:
        int numRollsToTarget(int n, int k, int target) {
            if (target < n || target > n * k) {
                return 0;
            }
    
            const int MOD = 1e9 + 7;
            vector<vector<int>> f(n+1, vector<int>(target+1));
            f[0][0] = 1;
            for (int i = 1; i <= n; ++i) {
                for (int j = 0; j <= target; ++j) {
                    for (int x = 1; x <= k; ++x) {
                        if (j - x >= 0) {
                            f[i][j] = (f[i][j] + f[i-1][j-x]) % MOD;
                        }
                    }
                }
            }
            return f[n][target];
        }
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    优化

    注意观察状态转移方程f[i][j] 只会从 f[i-1, ...] 转移过来,因此只需要存储第 i 行和第 i-1 行的值,使用两个一维数组代替二维数组进行转态转移。

    class Solution {
    public:
        int numRollsToTarget(int n, int k, int target) {
            if (target < n || target > n * k) {
                return 0;
            }
    
            const int MOD = 1e9 + 7;
            vector<int> f(target + 1);
            f[0] = 1;
            for (int i = 1; i <= n; ++i) {
                vector<int> g(target + 1);
                for (int j = 0; j <= target; ++j) {
                    for (int x = 1; x <= k; ++x) {
                        if (j - x >= 0) {
                            g[j] = (g[j] + f[j-x]) % MOD;
                        }
                    }
                }
                f = g;
            }
            return f[target];
        }
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    复杂度分析

    时间复杂度: O ( n ⋅ k ⋅ t a r g e t ) O(n \cdot k \cdot target) O(nktarget)

    空间复杂度: O ( n ⋅ t r a g e t ) O(n \cdot traget) O(ntraget),优化后的空间复杂度为 O ( t a r g e t ) O(target) O(target)


    写在最后

    如果文章内容有任何错误或者您对文章有任何疑问,欢迎私信博主或者在评论区指出 💬💬💬。

    如果大家有更优的时间、空间复杂度方法,欢迎评论区交流。

    最后,感谢您的阅读,如果感到有所收获的话可以给博主点一个 👍 哦。

  • 相关阅读:
    满级大牛 HuaWei 首次出这份 598 页【网络协议全彩手册】,建议大家收藏
    Shadowing Japanese(中上) Unit 2
    语言大模型的浮点运算分配
    艾美捷内毒素纯化树脂说明书
    Gin路由中间件详解
    关于HTML5画布canvas的功能
    python elasticsearch更新延迟问题
    干货 | 数字经济创新创业——如何造就成功的职业生涯
    Neovim 配置全面解析(下)
    数据治理----集中、分布的各种模式傻傻分不清楚
  • 原文地址:https://blog.csdn.net/weixin_54383080/article/details/134024781