 GeeksforGeeks App
Open App Browser
Continue

# Minimum cost to reach a point N from 0 with two different operations allowed

Given integers N, P and Q where N denotes the destination position. The task is to move from position 0 to position N with minimum cost possible and print the calculated cost. All valid movements are:

1. From position X you can go to position X + 1 with a cost of P
2. Or, you can go to the position 2 * X with a cost of Q

Examples:

Input: N = 1, P = 3, Q = 4
Output:
Move from position 0 to 1st position with cost = 3.
Input: N = 9, P = 5, Q = 1
Output: 13
Move from position 0 to 1st position with cost = 5,
then 1st to 2nd with cost = 1,
then 2nd to 4th with cost = 1,
then 4th to 8th with cost = 1,
finally 8th to 9th with cost = 5.
Total cost = 5 + 1 + 1 + 1 + 5 = 13.

Approach: Instead of going from beginning to destination we can start moving from the destination to initial position and keep track of the cost of jumps.

• If N is odd then the only valid move that could lead us here is N-1 to N with a cost of P.
• If N is even then we calculate cost of going from N to N/2 position with both the moves and take the minimum of them.
• When N equals 0, we return our total calculated cost.

Below is the implementation of above approach:

## C++

 `// CPP implementation of above approach` `#include ``using` `namespace` `std;` `// Function to return minimum``// cost to reach destination``int` `minCost(``int` `N, ``int` `P, ``int` `Q)``{``    ``// Initialize cost to 0``    ``int` `cost = 0;` `    ``// going backwards until we``    ``// reach initial position``    ``while` `(N > 0) {` `        ``if` `(N & 1) {``            ``cost += P;``            ``N--;``        ``}``        ``else` `{``            ``int` `temp = N / 2;` `            ``// if 2*X jump is``            ``// better than X+1``            ``if` `(temp * P > Q)``                ``cost += Q;``            ``// if X+1 jump is better``            ``else``                ``cost += P * temp;` `            ``N /= 2;``        ``}``    ``}` `    ``// return cost``    ``return` `cost;``}` `// Driver program``int` `main()``{``    ``int` `N = 9, P = 5, Q = 1;` `    ``cout << minCost(N, P, Q);` `    ``return` `0;``}`

## Java

 `// Java implementation of above approach` `class` `GFG{``// Function to return minimum``// cost to reach destination``static` `int` `minCost(``int` `N, ``int` `P, ``int` `Q)``{``    ``// Initialize cost to 0``    ``int` `cost = ``0``;` `    ``// going backwards until we``    ``// reach initial position``    ``while` `(N > ``0``) {` `        ``if` `((N & ``1``)>``0``) {``            ``cost += P;``            ``N--;``        ``}``        ``else` `{``            ``int` `temp = N / ``2``;` `            ``// if 2*X jump is``            ``// better than X+1``            ``if` `(temp * P > Q)``                ``cost += Q;``            ``// if X+1 jump is better``            ``else``                ``cost += P * temp;` `            ``N /= ``2``;``        ``}``    ``}` `    ``// return cost``    ``return` `cost;``}` `// Driver program``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``9``, P = ``5``, Q = ``1``;` `    ``System.out.println(minCost(N, P, Q));``}``}``// This code is contributed by mits`

## Python3

 `# Python implementation of above approach`  `# Function to return minimum``# cost to reach destination` `def` `minCost(N,P,Q):``    ``# Initialize cost to 0``    ``cost ``=` `0``  ` `    ``# going backwards until we``    ``# reach initial position``    ``while` `(N > ``0``): ``        ``if` `(N & ``1``):``            ``cost ``+``=` `P``            ``N``-``=``1``        ``else``:``            ``temp ``=` `N ``/``/` `2``;``  ` `            ``# if 2*X jump is``            ``# better than X+1``            ``if` `(temp ``*` `P > Q):``                ``cost ``+``=` `Q``            ``# if X+1 jump is better``            ``else``:``                ``cost ``+``=` `P ``*` `temp``            ``N ``/``/``=` `2``    ``return` `cost` `  ` `# Driver program``N ``=` `9``P ``=` `5``Q ``=` `1``print``(minCost(N, P, Q))``#this code is improved by sahilshelangia`

## C#

 `// C# implementation of above approach` `class` `GFG``{``// Function to return minimum``// cost to reach destination``static` `int` `minCost(``int` `N, ``int` `P, ``int` `Q)``{``    ``// Initialize cost to 0``    ``int` `cost = 0;` `    ``// going backwards until we``    ``// reach initial position``    ``while` `(N > 0)``    ``{` `        ``if` `((N & 1) > 0)``        ``{``            ``cost += P;``            ``N--;``        ``}``        ``else``        ``{``            ``int` `temp = N / 2;` `            ``// if 2*X jump is``            ``// better than X+1``            ``if` `(temp * P > Q)``                ``cost += Q;``                ` `            ``// if X+1 jump is better``            ``else``                ``cost += P * temp;` `            ``N /= 2;``        ``}``    ``}` `    ``// return cost``    ``return` `cost;``}` `// Driver Code``static` `void` `Main()``{``    ``int` `N = 9, P = 5, Q = 1;` `    ``System.Console.WriteLine(minCost(N, P, Q));``}``}` `// This code is contributed by mits`

## PHP

 ` 0)``    ``{` `        ``if` `(``\$N` `& 1)``        ``{``            ``\$cost` `+= ``\$P``;``            ``\$N``--;``        ``}``        ``else``        ``{``            ``\$temp` `= ``\$N` `/ 2;` `            ``// if 2*X jump is``            ``// better than X+1``            ``if` `(``\$temp` `* ``\$P` `> ``\$Q``)``                ``\$cost` `+= ``\$Q``;``                ` `            ``// if X+1 jump is better``            ``else``                ``\$cost` `+= ``\$P` `* ``\$temp``;` `            ``\$N` `/= 2;``        ``}``    ``}` `    ``// return cost``    ``return` `\$cost``;``}` `// Driver Code``\$N` `= 9; ``\$P` `= 5; ``\$Q` `= 1;` `echo` `minCost(``\$N``, ``\$P``, ``\$Q``);` `// This code is contributed``// by Akanksha Rai``?>`

## Javascript

 ``

Output:

`13`

Time Complexity: O(N)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up