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 = 4Output:3

Move from position 0 to 1st position with cost = 3.

Input:N = 9, P = 5, Q = 1Output: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;` `}` |

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

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

**Output:**

13

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**