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
- Climb n-th stair with all jumps from 1 to n allowed (Three Different Approaches)
- 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
- Sum of cost of all paths to reach a given cell in a Matrix
- Minimize cost of choosing and skipping array elements to reach end of the given array
- 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
- Counts paths from a point to reach Origin
- Minimum operations required to modify the array such that parity of adjacent elements is different

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.