掷骰子模拟

/*
 * Problem: We need to calculate the number of different sequences of dice rolls given the constraint
 * that each number i (1-6) cannot appear more than rollMax[i] times consecutively.
 * 
 * Approach: We will use dynamic programming to solve this problem. We will maintain a DP table dp[i][j][k]
 * where:
 * - i is the number of dice rolls
 * - j is the current number on the dice (1-6)
 * - k is the number of times the number j has appeared consecutively
 * The state transition will consider rolling a different number or continuing the streak of the current number
 * up to the limit specified in rollMax.
 * 
 * Note: Java Stream API is not very suitable for this type of problem since it's more functional in nature.
 * However, for demonstration purposes, we will use streams where applicable.
 */

import java.util.Arrays;
import java.util.stream.IntStream;

public class DiceRollSimulationStream {
    private static final int MOD = 1000000007;
    
    public int dieSimulator(int n, int[] rollMax) {
        int[][][] dp = new int[n + 1][6][16];
        IntStream.range(0, 6).forEach(i -> dp[1][i][1] = 1);
        
        IntStream.range(2, n + 1).forEach(roll -> {
            IntStream.range(0, 6).forEach(num -> {
                IntStream.range(0, 6).forEach(prevNum -> {
                    if (prevNum != num) {
                        IntStream.rangeClosed(1, rollMax[prevNum]).forEach(count -> {
                            dp[roll][num][1] = (dp[roll][num][1] + dp[roll - 1][prevNum][count]) % MOD;
                        });
                    } else {
                        IntStream.range(1, rollMax[num]).forEach(count -> {
                            dp[roll][num][count + 1] = (dp[roll][num][count + 1] + dp[roll - 1][num][count]) % MOD;
                        });
                    }
                });
            });
        });
        
        return IntStream.range(0, 6).flatMap(num -> 
            IntStream.rangeClosed(1, rollMax[num]).map(count -> dp[n][num][count])
        ).reduce(0, (a, b) -> (a + b) % MOD);
    }
}