GeeksforGeeks App
Open App
Browser
Continue

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

 ``

## Javascript

 ``

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

My Personal Notes arrow_drop_up