Expected number of moves to reach the end of a board | Dynamic programming

Given a linear board of length N numbered from 1 to N, the task is to find the expected number of moves required to reach the N^th cell of the board, if we start at cell numbered 1 and at each step we roll a cubical dice to decide the next move. Also, we cannot go outside the bounds of the board. Note that the expected number of moves can be fractional.
Examples: 

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

Approach: This problem can be solved using dynamic programming. To solve the problem, decide the states of the DP first. One way will be to use the distance between the current cell and the N^th cell to define the states of DP. Let's call this distance X. Thus dp[X] can be defined as the expected number of steps required to reach the end of the board of length X + 1 starting from the 1^st cell. 
Thus, the recurrence relation becomes: 
 

dp[X] = 1 + (dp[X - 1] + dp[X - 2] + dp[X - 3] + dp[X - 4] + dp[X - 5] + dp[X - 6]) / 6 
 

Now, for the base-cases: 
 

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 
 

Below is the implementation of the above approach: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
#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 implementation of the approach 
import java.io.*;
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 AnkitRai01

# 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 Kumar

// 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 AnkitRai01 

<script>

// Javascript implementation of the approach
var maxSize = 50;

// To store the states of dp
var dp = Array(maxSize);

// To determine whether a state
// has been solved before
var v = Array(maxSize);

// Function to return the count
function 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
var n = 10;
document.write( expectedSteps(n - 1).toFixed(5));

// This code is contributed by noob2000.
</script>  

7.36111

Time Complexity: O(N)
Auxiliary Space: O(N)

Efficient approach: Space optimization O(1)

To optimize space complexity we can use variables instead of arrays to store the states of the DP and determine whether a state has been solved before because in previous approach the current value is dependent upon the previous values stored in array. 

Implementation steps:

• Handle base cases: If bis 0, return 0. If x is less than or equal to 5, return 6.
• Initialize the previous values prev1, prev2, prev3, prev4, prev5, and prev6 to 6.
• Initialize the current value curr.
• Iterate from 6 to x (exclusive) to compute the current value based on the previous values.
• Calculate the current value as 1 plus the sum of the previous values divided by 6.
• Update the previous values by shifting their assignments.
• Return the final computed current value as the result.

Implementation:

#include <bits/stdc++.h>
using namespace std;

// Function to return the count
double expectedSteps(int x)
{
    // Base cases
    if (x == 0)
        return 0;
    if (x <= 5)
        return 6;
  
    // initializing previous values
    double prev1 = 6; // expectedSteps(x - 1)
    double prev2 = 6; // expectedSteps(x - 2)
    double prev3 = 6; // expectedSteps(x - 3)
    double prev4 = 6; // expectedSteps(x - 4)
    double prev5 = 6; // expectedSteps(x - 5)
    double prev6 = 6; // expectedSteps(x - 6)
    
      // current value
    double curr;
  
  // iterate over subproblem to get current
  // value from previous computations
    for (int i = 6; i < x; i++) {
        curr = 1 + (prev1 + prev2 + prev3 + prev4 + prev5 + prev6) / 6;
      
      // assigning values to iterate further
        prev1 = prev2;
        prev2 = prev3;
        prev3 = prev4;
        prev4 = prev5;
        prev5 = prev6;
        prev6 = curr;
    }

    return curr;
}

// Driver code
int main()
{
    int n = 10;
    
      // function call
    cout << expectedSteps(n - 1);

    return 0;
}

import java.util.Scanner;

public class GFG {
    // Function to return the count
    static double expectedSteps(int x)
    {
        // Base cases
        if (x == 0)
            return 0;
        if (x <= 5)
            return 6;

        // Initializing previous values
        double prev1 = 6; // expectedSteps(x - 1)
        double prev2 = 6; // expectedSteps(x - 2)
        double prev3 = 6; // expectedSteps(x - 3)
        double prev4 = 6; // expectedSteps(x - 4)
        double prev5 = 6; // expectedSteps(x - 5)
        double prev6 = 6; // expectedSteps(x - 6)

        // Current value
        double curr = 0;

        // Iterate over subproblem to get the current
        // value from previous computations
        for (int i = 6; i < x; i++) {
            curr = 1
                   + (prev1 + prev2 + prev3 + prev4 + prev5
                      + prev6)
                         / 6;

            // Assigning values to iterate further
            prev1 = prev2;
            prev2 = prev3;
            prev3 = prev4;
            prev4 = prev5;
            prev5 = prev6;
            prev6 = curr;
        }

        return curr;
    }

    // Driver code
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = 10;

        // Function call
        System.out.println(expectedSteps(n - 1));
        sc.close();
    }
}

def expected_steps(x):
    # Base cases
    if x == 0:
        return 0
    if x <= 5:
        return 6

    # initializing previous values
    prev1 = 6  # expectedSteps(x - 1)
    prev2 = 6  # expectedSteps(x - 2)
    prev3 = 6  # expectedSteps(x - 3)
    prev4 = 6  # expectedSteps(x - 4)
    prev5 = 6  # expectedSteps(x - 5)
    prev6 = 6  # expectedSteps(x - 6)

    # current value
    curr = 0

    # iterate over subproblem to get current
    # value from previous computations
    for i in range(6, x):
        curr = 1 + (prev1 + prev2 + prev3 + prev4 + prev5 + prev6) / 6

        # assigning values to iterate further
        prev1 = prev2
        prev2 = prev3
        prev3 = prev4
        prev4 = prev5
        prev5 = prev6
        prev6 = curr

    return curr


def main():
    n = 10

    # function call
    print(expected_steps(n - 1))


if __name__ == "__main__":
    main()

using System;

namespace ExpectedStepsExample
{
    class GFG
    {
        // Function to return the count
        static double ExpectedSteps(int x)
        {
            // Base cases
            if (x == 0)
                return 0;
            if (x <= 5)
                return 6;

            // initializing previous values
            double prev1 = 6; // ExpectedSteps(x - 1)
            double prev2 = 6; // ExpectedSteps(x - 2)
            double prev3 = 6; // ExpectedSteps(x - 3)
            double prev4 = 6; // ExpectedSteps(x - 4)
            double prev5 = 6; // ExpectedSteps(x - 5)
            double prev6 = 6; // ExpectedSteps(x - 6)

            // current value
            double curr = 0;

            // iterate over subproblem to get the current
            // value from previous computations
            for (int i = 6; i < x; i++)
            {
                curr = 1 + (prev1 + prev2 + prev3 + prev4 + prev5 + prev6) / 6;

                // assigning values to iterate further
                prev1 = prev2;
                prev2 = prev3;
                prev3 = prev4;
                prev4 = prev5;
                prev5 = prev6;
                prev6 = curr;
            }

            return curr;
        }

        // Driver code
        static void Main(string[] args)
        {
            int n = 10;

            // function call
            Console.WriteLine(ExpectedSteps(n - 1));
        }
    }
}

function expectedSteps(x) {
    // Base cases
    if (x === 0)
        return 0;
    if (x <= 5)
        return 6;

    // Initializing previous values
    let prev1 = 6; // expectedSteps(x - 1)
    let prev2 = 6; // expectedSteps(x - 2)
    let prev3 = 6; // expectedSteps(x - 3)
    let prev4 = 6; // expectedSteps(x - 4)
    let prev5 = 6; // expectedSteps(x - 5)
    let prev6 = 6; // expectedSteps(x - 6)

    // Current value
    let curr;

    // Iterate over subproblem to get current
    // value from previous computations
    for (let i = 6; i < x; i++) {
        curr = 1 + (prev1 + prev2 + prev3 + prev4 + prev5 + prev6) / 6;

        // Assigning values to iterate further
        prev1 = prev2;
        prev2 = prev3;
        prev3 = prev4;
        prev4 = prev5;
        prev5 = prev6;
        prev6 = curr;
    }

    return curr;
}

// Driver code
const n = 10;

// Function call
console.log(expectedSteps(n - 1));

Output: 

7.36111

Time Complexity: O(N)
Auxiliary Space: O(1)