Minimum time to reach a point with +t and -t moves at time t

Given a positive coordinate ‘X’ and you are at coordinate ‘0’, the task is to find the minimum time required to get to coordinate ‘X’ with the following move : 
At time ‘t’, you can either stay at the same position or take a jump of length exactly ‘t’ either to the left or to the right. In other words, you can be at coordinate ‘x – t’, ‘x’ or ‘x + t’ at time ‘t’ where ‘x’ is the current position.
Examples:

Input: 6
Output: 3
At time 1, jump from x = 0 to x = 1 (x = x + 1)
At time 2, jump from x = 1 to x = 3 (x = x + 2)
At time 3, jump from x = 3 to x = 6 (x = x + 3)
So, minimum required time is 3.

Input: 9
Output: 4
At time 1, do not jump i.e x = 0 
At time 2, jump from x = 0 to x = 2 (x = x + 2)
At time 3, jump from x = 2 to x = 5 (x = x + 3)
At time 4, jump from x = 5 to x = 9 (x = x + 4)
So, minimum required time is 4.

Approach: The following greedy strategy works: 
We just find the minimum ‘t’ such that 1 + 2 + 3 + … + t >= X. 

• If (t * (t + 1)) / 2 = X then answer is ‘t’.
• Else if (t * (t + 1)) / 2 > X, then we find (t * (t + 1)) / 2 – X and remove this number from the sequence [1, 2, 3, …, t]. The resulting sequence sums up to ‘X’.

Below is the implementation of the above approach: 

C++

// C++ implementation of the above approach

#include <iostream>

using namespace std;

   // returns the minimum time
    // required to reach 'X'
    long cal_minimum_time(long X)
    {

        // Stores the minimum time
        long t = 0;
        long sum = 0;

        while (sum < X) {

            // increment 't' by 1
            t++;

            // update the sum
            sum = sum + t;
        }

        return t;
    }

// Driver code
int main()
{
        long n = 6;
        long ans = cal_minimum_time(n);
        cout << "The minimum time required is : " << ans ;

   return 0;

   // This code is contributed by ANKITRAI1
}

Java

// Java implementation of the above approach
class GFG {

    // returns the minimum time
    // required to reach 'X'
    static long cal_minimum_time(long X)
    {

        // Stores the minimum time
        long t = 0;
        long sum = 0;

        while (sum < X) {

            // increment 't' by 1
            t++;

            // update the sum
            sum = sum + t;
        }

        return t;
    }

    // Driver code
    public static void main(String[] args)
    {
        long n = 6;
        long ans = cal_minimum_time(n);
        System.out.println("The minimum time required is : " + ans);
    }
}

Python3

# Python 3 implementation of the
# above approach

# returns the minimum time
# required to reach 'X'
def cal_minimum_time(X):

    # Stores the minimum time
    t = 0
    sum = 0

    while (sum < X):

        # increment 't' by 1
        t = t + 1

        # update the sum
        sum = sum + t;

    return t;

# Driver code
if __name__ == '__main__':
    n = 6
    ans = cal_minimum_time(n)
    print("The minimum time required is :", ans)

# This code is contributed By
# Surendra_Gangwar

C#

// C#  implementation of the above approach
using System;

public class GFG{

    // returns the minimum time
    // required to reach 'X'
    static long cal_minimum_time(long X)
    {

        // Stores the minimum time
        long t = 0;
        long sum = 0;

        while (sum < X) {

            // increment 't' by 1
            t++;

            // update the sum
            sum = sum + t;
        }

        return t;
    }

    // Driver code
    static public void Main (){
        long n = 6;
        long ans = cal_minimum_time(n);
        Console.WriteLine("The minimum time required is : " + ans);
    }
}

PHP

<?php
// PHP implementation of the
// above approach

// returns the minimum time
// required to reach 'X'
function cal_minimum_time($X)
{
    // Stores the minimum time
    $t = 0;
    $sum = 0;

    while ($sum < $X)
    {

        // increment 't' by 1
        $t++;

        // update the sum
        $sum = $sum + $t;
    }

    return $t;
}

// Driver code
$n = 6;
$ans = cal_minimum_time($n);
echo "The minimum time required is : " . $ans;

// This code is contributed
// by ChitraNayal
?>

Javascript

<script>

// JavaScript implementation of the above approach

    // returns the minimum time
    // required to reach 'X'
    function cal_minimum_time(X)
    {

        // Stores the minimum time
        let t = 0;
        let sum = 0;

        while (sum < X) {

            // increment 't' by 1
            t++;

            // update the sum
            sum = sum + t;
        }

        return t;
    }

// driver code

  let n = 6;
  let ans = cal_minimum_time(n);
  document.write("The minimum time required is : " + ans);

</script>

Output:

The minimum time required is : 3

Time Complexity: O(n), since there is a while loop that runs for n times.
Auxiliary Space: O(1), since no extra space has been taken.

Approach#2: Using math

The problem can be solved using dynamic programming. We can start from the base case where n=0, and build the solution recursively by considering all possible jumps that can be taken at each step. We can use a memoization table to store the minimum time required to reach a point, so that we can avoid recomputing the same subproblems multiple times.

Algorithm

1. Create a memoization table dp of size n+1 and initialize all values to infinity.
2. Set dp[0] to 0.
For i from 1 to n, compute dp[i] as follows:
If i is a triangular number, set dp[i] to the square root of 2*i.
Otherwise, set dp[i] to dp[i-1] + 1.
For each jump size j from 1 to i, compute the time required to reach i-j*(j+1)/2 and add j to it.
If this time is less than dp[i], update dp[i] with this new minimum time.
3. Return dp[n].

Python3

import math
from math import ceil
def min_time(n):
    if n <= 0:
        return 0
    elif (int(math.sqrt(1+8*n))-1)/2 == int((math.sqrt(1+8*n))-1)/2:
        return int(ceil((math.sqrt(1+8*n))-1)/2)
    else:
        time = min_time(n-1) + 1
        jump = 1
        while jump*(jump+1)/2 <= n:
            time = min(time, min_time(n-jump*(jump+1)/2) + jump)
            jump += 1
        return ceil(time)

n=6
print(min_time(n))

Output

3

Time complexity: Computing the time required to reach a point takes O(1) time.
The outer loop runs for n iterations, and the inner loop runs for a maximum of sqrt(2*n) iterations.
Therefore, the time complexity of the algorithm is O(n*sqrt(n)).
Space complexity: We need an array of size n+1 to store the memoization table.
Therefore, the space complexity of the algorithm is O(n).