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

16 Nov, 2021
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 POr, you can go to the position 2 * X with a cost of Q
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++
Java
Python3
C#
PHP
Javascript
// CPP implementation of above approach #include <bits/stdc++.h>using namespace std; // Function to return minimum// cost to reach destinationint 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 programint main(){    int N = 9, P = 5, Q = 1;     cout << minCost(N, P, Q);     return 0;}
// Java implementation of above approach class GFG{// Function to return minimum// cost to reach destinationstatic 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 programpublic 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
# 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 programN = 9P = 5Q = 1print(minCost(N, P, Q))#this code is improved by sahilshelangia
// C# implementation of above approach class GFG{// Function to return minimum// cost to reach destinationstatic 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 Codestatic void Main(){    int N = 9, P = 5, Q = 1;     System.Console.WriteLine(minCost(N, P, Q));}} // This code is contributed by mits
<?php// PHP implementation of above approach // Function to return minimum// cost to reach destinationfunction 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?>
<script>//Javascript implementation of above approach // Function to return minimum// cost to reach destinationfunction minCost( N, P, Q){    // Initialize cost to 0    var cost = 0;     // going backwards until we    // reach initial position    while (N > 0) {         if (N & 1) {            cost += P;            N--;        }        else {            var temp =parseInt( 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 = parseInt(N / 2);        }    }     // return cost    return cost;}var N = 9, P = 5, Q = 1; document.write( minCost(N, P, Q)); //This code is contributed by SoumikMondal</script>
13
 
Time Complexity: O(N)
Auxiliary Space: O(1)
sahilshelangia
Mithun Kumar
Akanksha_Rai
SoumikMondal
samim2000
Backtracking
Dynamic Programming
Greedy
Mathematical
Dynamic Programming
Greedy
Mathematical
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Hamiltonian Cycle | Backtracking-6
Generate all the binary strings of N bits
Backtracking to find all subsets
Printing all solutions in N-Queen Problem
Subset Sum | Backtracking-4
Largest Sum Contiguous Subarray
Program for Fibonacci numbers
0-1 Knapsack Problem | DP-10
Longest Common Subsequence | DP-4
Subset Sum Problem | DP-25