Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 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: 
 

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

Javascript




<script>
//Javascript implementation of above approach
 
// Function to return minimum
// cost to reach destination
function 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>

Output: 

13

 

Time Complexity: O(N)

Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!