给定长度为N的从1到N的线性板，任务是找到到达板的第N个单元所需的预期移动数，如果我们从编号为1的单元开始，并且每一步都滚动一个立方骰子决定下一步行动。而且，我们不能走出董事会的界限。请注意，预期的移动次数可以是分数。
例子：
Input: N = 8
Output: 7
p1 = (1 / 6) | 1-step -> 6 moves expected to reach the end
p2 = (1 / 6) | 2-steps -> 6 moves expected to reach the end
p3 = (1 / 6) | 3-steps -> 6 moves expected to reach the end
p4 = (1 / 6) | 4-steps -> 6 moves expected to reach the end
p5 = (1 / 6) | 5-steps -> 6 moves expected to reach the end
p6 = (1 / 6) | 6-steps -> 6 moves expected to reach the end
If we are 7 steps away, then we can end up at 1, 2, 3, 4, 5, 6 steps
away with equal probability i.e. (1 / 6).
Look at the above simulation to understand better.
dp[N – 1] = dp[7]
= 1 + (dp[1] + dp[2] + dp[3] + dp[4] + dp[5] + dp[6]) / 6
= 1 + 6 = 7
Input: N = 10
Output: 7.36111
方法：可以使用动态编程解决此问题。要解决该问题，请先确定DP的状态。一种方法是使用当前单元格与第N个单元格之间的距离来定义DP的状态。将此距离称为X。因此DP [X]作为步骤的预期数量需要达到长度X + 1从第一单元开始的基板的端部可以限定。
因此，递归关系变为：
dp[X] = 1 + (dp[X – 1] + dp[X – 2] + dp[X – 3] + dp[X – 4] + dp[X – 5] + dp[X – 6]) / 6
现在，对于基本情况：
dp[0] = 0
Let’s try to calculate dp[1].
dp[1] = 1 + 5 * (dp[1]) / 6 + dp[0] (Why? its because (5 / 6) is the probability it stays stuck at 1.)
dp[1] / 6 = 1 (since dp[0] = 0)
dp[1] = 6
Similarly, dp[1] = dp[2] = dp[3] = dp[4] = dp[5] = 6
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
#define maxSize 50
using namespace std;
// To store the states of dp
double dp[maxSize];
// To determine whether a state
// has been solved before
int v[maxSize];
// Function to return the count
double expectedSteps(int x)
{
// Base cases
if (x == 0)
return 0;
if (x <= 5)
return 6;
// If a state has been solved before
// it won't be evaluated again
if (v[x])
return dp[x];
v[x] = 1;
// Recurrence relation
dp[x] = 1 + (expectedSteps(x - 1) +
expectedSteps(x - 2) +
expectedSteps(x - 3) +
expectedSteps(x - 4) +
expectedSteps(x - 5) +
expectedSteps(x - 6)) / 6;
return dp[x];
}
// Driver code
int main()
{
int n = 10;
cout << expectedSteps(n - 1);
return 0;
} Java
// Java implementation of the approach
class GFG
{
static int maxSize = 50;
// To store the states of dp
static double dp[] = new double[maxSize];
// To determine whether a state
// has been solved before
static int v[] = new int[maxSize];
// Function to return the count
static double expectedSteps(int x)
{
// Base cases
if (x == 0)
return 0;
if (x <= 5)
return 6;
// If a state has been solved before
// it won't be evaluated again
if (v[x] == 1)
return dp[x];
v[x] = 1;
// Recurrence relation
dp[x] = 1 + (expectedSteps(x - 1) +
expectedSteps(x - 2) +
expectedSteps(x - 3) +
expectedSteps(x - 4) +
expectedSteps(x - 5) +
expectedSteps(x - 6)) / 6;
return dp[x];
}
// Driver code
public static void main (String[] args)
{
int n = 10;
System.out.println(expectedSteps(n - 1));
}
}
// This code is contributed by AnkitRai01Python3
# Python3 implementation of the approach
maxSize = 50
# To store the states of dp
dp = [0] * maxSize
# To determine whether a state
# has been solved before
v = [0] * maxSize
# Function to return the count
def expectedSteps(x):
# Base cases
if (x == 0):
return 0
if (x <= 5):
return 6
# If a state has been solved before
# it won't be evaluated again
if (v[x]):
return dp[x]
v[x] = 1
# Recurrence relation
dp[x] = 1 + (expectedSteps(x - 1) +
expectedSteps(x - 2) +
expectedSteps(x - 3) +
expectedSteps(x - 4) +
expectedSteps(x - 5) +
expectedSteps(x - 6)) / 6
return dp[x]
# Driver code
n = 10
print(round(expectedSteps(n - 1), 5))
# This code is contributed by Mohit KumarC#
// C# implementation of the approach
using System;
class GFG
{
static int maxSize = 50;
// To store the states of dp
static double []dp = new double[maxSize];
// To determine whether a state
// has been solved before
static int []v = new int[maxSize];
// Function to return the count
static double expectedSteps(int x)
{
// Base cases
if (x == 0)
return 0;
if (x <= 5)
return 6;
// If a state has been solved before
// it won't be evaluated again
if (v[x] == 1)
return dp[x];
v[x] = 1;
// Recurrence relation
dp[x] = 1 + (expectedSteps(x - 1) +
expectedSteps(x - 2) +
expectedSteps(x - 3) +
expectedSteps(x - 4) +
expectedSteps(x - 5) +
expectedSteps(x - 6)) / 6;
return dp[x];
}
// Driver code
public static void Main ()
{
int n = 10;
Console.WriteLine(expectedSteps(n - 1));
}
}
// This code is contributed by AnkitRai017.36111