Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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);
    }
}


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>


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
?>


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].

C++




#include <iostream>
#include <cmath>
 
// Function to calculate the minimum time
int minTime(int n) {
    if (n <= 0) {
        return 0;
    } else if ((int(std::sqrt(1 + 8 * n)) - 1) / 2 == int((std::sqrt(1 + 8 * n)) - 1) / 2) {
        // If n is a triangular number, return its square root minus 1 divided by 2
        return int(std::ceil((std::sqrt(1 + 8 * n) - 1) / 2));
    } else {
        int time = minTime(n - 1) + 1;
        int jump = 1;
        while (jump * (jump + 1) / 2 <= n) {
            // Recursively calculate the minimum time for different jump values
            time = std::min(time, minTime(n - jump * (jump + 1) / 2) + jump);
            jump++;
        }
        return std::ceil(time);
    }
}
 
int main() {
    int n = 6;
    std::cout << minTime(n) << std::endl; // Print the minimum time for n
    return 0;
}


Java




import java.lang.Math;
 
public class MinTime {
    public static int minTime(int n) {
        if (n <= 0) {
            return 0;
        } else if ((int)(Math.sqrt(1 + 8 * n) - 1) / 2 == (int)((Math.sqrt(1 + 8 * n) - 1) / 2)) {
            return (int)Math.ceil((Math.sqrt(1 + 8 * n) - 1) / 2);
        } else {
            int time = minTime(n - 1) + 1;
            int jump = 1;
            while (jump * (jump + 1) / 2 <= n) {
                time = Math.min(time, minTime(n - (int)(jump * (jump + 1) / 2)) + jump);
                jump++;
            }
            return (int)Math.ceil(time);
        }
    }
 
    public static void main(String[] args) {
        int n = 6;
        System.out.println(minTime(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))


C#




using System;
 
class Program
{
    // Function to calculate the minimum time
    static int MinTime(int n)
    {
        if (n <= 0)
        {
            return 0;
        }
        else if ((int)(Math.Sqrt(1 + 8 * n)) - 1 / 2 == (int)((Math.Sqrt(1 + 8 * n)) - 1) / 2)
        {
            // If n is a triangular number, return its square root minus 1 divided by 2
            return (int)Math.Ceiling((Math.Sqrt(1 + 8 * n) - 1) / 2.0);
        }
        else
        {
            int time = MinTime(n - 1) + 1;
            int jump = 1;
            while (jump * (jump + 1) / 2 <= n)
            {
                // Recursively calculate the minimum time for different jump values
                time = Math.Min(time, MinTime(n - (int)(jump * (jump + 1) / 2.0)) + jump);
                jump++;
            }
            return (int)Math.Ceiling((double)time); // Explicitly cast to double to resolve ambiguity
        }
    }
 
    static void Main()
    {
        int n = 6;
        Console.WriteLine(MinTime(n)); // Print the minimum time for n
    }
}
 
 
// This code is contributed by rambabuguphka


Javascript




// Define a function to calculate the minimum time required to reach the given target number 'n'.
function minTime(n) {
    // Base case: If 'n' is less than or equal to 0, return 0 as no time is needed.
    if (n <= 0) {
        return 0;
    } else if (Math.floor(Math.sqrt(1 + 8 * n) - 1) / 2 === Math.floor((Math.sqrt(1 + 8 * n) - 1) / 2)) {
        // Check if 'n' is a triangular number. If so, return the ceiling of its square root minus 1 divided by 2.
        return Math.ceil((Math.sqrt(1 + 8 * n) - 1) / 2);
    } else {
        // Recursive case: Calculate the minimum time to reach 'n' by considering different possible jumps.
        let time = minTime(n - 1) + 1; // Initialize time with the cost of one jump.
 
        let jump = 1;
        // Explore different jump possibilities to minimize time.
        while (jump * (jump + 1) / 2 <= n) {
            time = Math.min(time, minTime(n - Math.floor(jump * (jump + 1) / 2)) + jump);
            jump++;
        }
 
        return Math.ceil(time); // Return the minimum time, rounded up to the nearest integer.
    }
}
 
// Example usage: Calculate the minimum time for 'n' = 6 and log the result.
let n = 6;
console.log(minTime(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).



Last Updated : 29 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads