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:

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

**Examples:**

Input:N = 1, P = 3, Q = 4

Output:3

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 <bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP implementation of above approach ` ` ` `// Function to return minimum ` `// cost to reach destination ` `function` `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` `--; ` ` ` `} ` ` ` `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 ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

13

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Minimum cost to reach end of array array when a maximum jump of K index is allowed
- Minimum cost to sort strings using reversal operations of different costs
- Minimum Cost Path with Left, Right, Bottom and Up moves allowed
- Minimum cost for acquiring all coins with k extra coins allowed with every coin
- Find the minimum cost to reach destination using a train
- Minimum cost to reach the top of the floor by climbing stairs
- Minimum time to reach a point with +t and -t moves at time t
- Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
- Minimize Cost with Replacement with other allowed
- Minimum cost to convert str1 to str2 with the given operations
- Minimum Cost to make all array elements equal using given operations
- Number from a range [L, R] having Kth minimum cost of conversion to 1 by given operations
- Minimize cost to convert given two integers to zero using given operations
- Climb n-th stair with all jumps from 1 to n allowed (Three Different Approaches)
- Sum of cost of all paths to reach a given cell in a Matrix
- Counts paths from a point to reach Origin
- Number of steps required to reach point (x,y) from (0,0) using zig-zag way
- Counts paths from a point to reach Origin : Memory Optimized
- Minimum operations required to modify the array such that parity of adjacent elements is different
- Rotation of a point about another point in C++

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.