LeetCode 1223. 掷骰子模拟 Dice Roll Simulation - Java - DP

题目链接:1223. 掷骰子模拟

有一个骰子模拟器会每次投掷的时候生成一个 1 到 6 的随机数。

不过我们在使用它时有个约束,就是使得投掷骰子时,连续 掷出数字 i 的次数不能超过 rollMax[i]i 从 1 开始编号)。

现在,给你一个整数数组 rollMax 和一个整数 n,请你来计算掷 n 次骰子可得到的不同点数序列的数量。

假如两个序列中至少存在一个元素不同,就认为这两个序列是不同的。由于答案可能很大,所以请返回 \(10^9 + 7\) 之后的结果。

示例1:

输入:n = 2, rollMax = [1,1,2,2,2,3]
输出:34
解释:我们掷 2 次骰子,如果没有约束的话,共有 6 * 6 = 36 种可能的组合。但是根据
    rollMax 数组,数字 1 和 2 最多连续出现一次,所以不会出现序列 (1,1) 和 (2,2)。
    因此,最终答案是 36-2 = 34。

示例2:

输入:n = 2, rollMax = [1,1,1,1,1,1]
输出:30

示例3:

输入:n = 3, rollMax = [1,1,1,2,2,3]
输出:181

提示:

  • 1 <= n <= 5000
  • rollMax.length == 6
  • 1 <= rollMax[i] <= 15

时间复杂度: \(O(n×6^2)\)
空间复杂度: \(O(n)\)

Java代码:

class Solution {
    private int mod = 1000000007;

    public int dieSimulator(int n,
                            int[] rollMax) {
        long[][] dp = new long[n + 1][7];

        for (int point = 1; point <= 6; ++point) {
            dp[1][point] = 1;
        }

        for (int i = 2; i <= n; ++i) {
            for (int j = 1; j <= 6; ++j) {
                dp[i][j] = getNum(dp, i, j, rollMax) % mod;
            }
        }

        long ret = 0;
        for (int point = 1; point <= 6; ++point) {
            ret += dp[n][point];
            ret %= mod;
        }

        if (ret < 0) {
            ret += mod;
        }

        return (int) ret;
    }

    private long getNum(long[][] dp,
                        int i,
                        int j,
                        int[] rollMax) {
        long ret = 0;
        for (int point = 0; point <= 6; ++point) {
            ret += dp[i - 1][point];
            ret %= mod;
        }

        int repeatNum = rollMax[j - 1];
        // 去掉重复的统计数据
        if (i > repeatNum) {
            ret -= getRepeat(dp, i - 1, j, repeatNum);
            ret %= mod;
        }

        return ret;
    }

    private long getRepeat( long[][] dp,
                            int i,
                            int j,
                            int repeatNum) {
        if (i == repeatNum) {
            return 1;
        }

        if (repeatNum == 1) {
            return dp[i][j];
        } else {
            long ret = 0;
            for (int point = 1; point <= 6; ++point) {
                if (point != j) {
                    ret += dp[i - repeatNum][point];
                    ret %= mod;
                }
            }
            return ret;
        }
    }
}

Java代码:

// 2019年10月13日22:56:49
// 这是我自己写的,时间复杂度为O(n×6^3)
class Solution {
    public int dieSimulator(int n, int[] rollMax) {
        int mod = 1000000007;
        long [][] arr = new long[n + 1][7];
        Arrays.fill(arr[1], 1);
        for (int i = 2; i <= n; ++i) {
            for (int j = 1; j <= 6; ++j) {
                if (rollMax[j - 1] == 1) {
                    for (int k = 1; k <= 6; ++k) {
                        if (k == j) {
                            continue;
                        }
                        arr[i][j] += arr[i - 1][k];
                        arr[i][j] %= mod;
                    }
                    continue;
                }
                if (i - rollMax[j - 1] < 1) {
                    for (int k = 1; k <= 6; ++k) {
                        arr[i][j] += arr[i - 1][k];
                        arr[i][j] %= mod;
                    }
                    continue;
                }
                for (int k = 1; k <= 6; ++k) {
                    if (k == j) {
                        for (int k1 = 1; k1 <= 6; ++k1) {
                            if (k1 != j) {
                                arr[i][j] += arr[i - rollMax[j - 1]][k1];
                                arr[i][j] %= mod;
                            }
                        }
                        continue;
                    }
                    arr[i][j] += arr[i - 1][k];
                    arr[i][j] %= mod;
                }
            }
        }
        long ret = 0;
        for (long a : arr[n]) {
            ret += a;
            ret %= mod;
        }
        return (int) ret;
    }
}

原文地址:https://www.cnblogs.com/wowpH/p/dice_roll_simulation.html

时间: 2024-10-09 01:25:02

LeetCode 1223. 掷骰子模拟 Dice Roll Simulation - Java - DP的相关文章

Leetcode-5224 Dice Roll Simulation(掷骰子模拟)

1 typedef pair<int,int> P; 2 typedef long long ll; 3 #define _for(i,a,b) for(register int i = (a);i < b;i ++) 4 #define _rep(i,a,b) for(register int i = (a);i > b;i --) 5 #define INF 0x3f3f3f3f 6 #define MOD 1000000007 7 #define maxn 10003 8 #

LeetCode 1223. Dice Roll Simulation

原题链接在这里:https://leetcode.com/problems/dice-roll-simulation/ 题目: A die simulator generates a random number from 1 to 6 for each roll. You introduced a constraint to the generator such that it cannot roll the number i more than rollMax[i] (1-indexed) c

python应用-掷骰子模拟-pygal

pygal安装: Linux下: pip install pygal Windows下: python -m pip install pygal 效果如图: # -*- coding: utf-8 -*- """ Created on Fri Sep 28 23:07:29 2018 @author: pprp """ from random import randint import pygal class Die(): def __init_

模拟算法_掷骰子游戏&amp;&amp;猜数游戏

模拟算法是用随机函数来模拟自然界中发生的不可预测的情况,C语言中是用srand()和rand()函数来生成随机数. 先来介绍一下随机数的生成: 1.产生不定范围的随机数 函数原型:int rand() 产生一个介于0~RAD_MAX间的整数,其具体值与系统有关系.Linux下为2147483647.我们可以在include文件夹中的stdlib.h中可以看到(Linux在usr目录下,Windows在安装目录下) 1 #include<stdio.h> 2 #include<stdlib

【算法】模拟掷骰子

模拟掷骰子.以下代码能够计算每种两个骰子之和的准确概率分布: int SIDES = 6; double[] dist = new double[2*SIDES+1]; for (int i = 1; i <= SIDES; i++) for (int j = 1; i <= SIDES; j++) dist[i+j] += 1.0; for (int k = 2; k <= 2*SIDES; k++) dist[k] /= 36.0; dist[i] 的值就是两个骰子之和为i的概率.用

[leetcode 周赛 149] 1155 掷骰子的N种方法

目录 1155 Number of Dice Rolls With Target Sum 掷骰子的N种方法 描述 思路 代码实现 1155 Number of Dice Rolls With Target Sum 掷骰子的N种方法 描述 这里有 d 个一样的骰子,每个骰子上都有 f 个面,分别标号为 1, 2, ..., f. 我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和. 如果需要掷出的总点数为 target,请你计算出有多少种不同的组合情况(所有的组合情况总共有f^d 种),模10

如何在Unity 3D中掷骰子

1.介绍 2.滚一个骰子 3.导入模型 4.添加脚本 5.方法 6.识别骰子上的随机面值 客观的 这篇文章的主要目的是给你一个关于如何在Unity 3D中掷骰子的想法. 第一步介绍 1.构建一个棋盘游戏,但对骰子有问题;这里是一个示例代码,演示如何像真正的骰子一样掷骰子,以及如何在游戏控2.制台上识别骰子的表面值. 3.这个问题分为两个主要部分: 4.如何掷骰子? 5.确定在1和6之间的随机整数(6个标准骰子)的面值. 第二步掷骰子 2.1导入模型 将一个标准骰子模型导入到unity3D中.调整

hdu 5995 Guessing the Dice Roll(AC自动机+矩阵)

题目链接:hdu 5995 Guessing the Dice Roll 题意: 有一个6面的骰子,有n(n≤10)个人每个人猜了一个长度为l(l≤10)的序列,不停的掷骰子直到满足一个人的序列则那个人获胜,求每个人获胜的概率. 题解: 将他们猜的串插入AC自动机,然后转移k次,这里k要足够大才能收敛,然后因为总节点数最多才60个,所以用矩阵来加速. 正解应该是用高斯消元来做这个事情. 1 #include<bits/stdc++.h> 2 #define mst(a,b) memset(a,

华为历年试题(掷骰子游戏 7)

问题描述: 在掷骰子游戏中,会根据所掷数字在地图中前进几步,前进完成后需要根据当前地图位置所示的障碍进行相应操作,其中障碍表示: 1)  9:无障碍 2)  1:停掷一轮,即下轮所掷数字无效: 3)  2:后退两步,如果已经到起点不再后退: 4)  3:奖励前进一步 如果在游戏过程中,已经走到地图终点,则游戏结束.根据输入的地图数组,和5个骰子数的数组,返回最终玩家前进了多少步. 要求实现函数: void dice(int map_len, int* map, int* dice_val, in