允许通过两种不同的操作从0到达N点的最小成本

给定整数N，P和Q ，其中N表示目的地位置。任务是以最小的成本从位置0移至位置N ，并打印计算出的成本。所有有效的动作是：

1. 从位置X您可以转到位置X + 1 (成本为P)
2. 或者，您可以以成本Q转到位置2 * X

例子：

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.

方法：与其从头到尾，不如从头到尾，我们可以开始追踪跳跃的成本。

• 如果N为奇数，那么唯一可以导致我们出现的有效举动是N-1到N ，代价为P。
• 如果N是偶数，则我们计算两次移动从N到N / 2位置的成本，并取其中的最小值。
• 当N等于0时，我们返回总的计算成本。

下面是上述方法的实现：

C++

// CPP implementation of above approach
  
#include 
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

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

输出：

13