给定两个整数M和N ,任务是通过重复添加M的当前值的偶数除数( M除外)来找到将M转换为N的最小成本。
The cost to add an even divisor of the current value of M, say d, is equal to M / d.
如果无法将M转换为N ,则打印“ -1” 。
例子:
Input: M = 6, N = 24
Output: 10
Explanation:
Step 1: M = 6 + 2 = 8, Cost = (6 / 2) = 3
Step 2: M = 8 + 4 = 12, Cost = 3 + (8 / 2) = 5
Step 3: M = 12 + 6 = 18, Cost = 5 + (12/ 6) = 7
Step 4: M = 18 + 6 = 24, Cost = 7 + (18 / 6) = 10
Therefore, the minimum cost to convert M to N is equal to 10.
Input: M = 9, N = 17
Output: -1
Explanation:
Since there are no even divisors of 9, therefore, conversion is not possible.
天真的方法:最简单的方法是遍历给定数M的所有可能偶数除数,然后递归计算将M更改为N的最小成本。形成的递归关系由下式给出:
min_cost = Math.min(min_cost, m / i + minSteps(m + i, n))
下面是上述方法的实现:
C++
// C++ program for the above approach
#include
using namespace std;
int inf = 1000000008;
// Function to find the value of
// minimum steps to convert m to n
int minSteps(int m, int n)
{
// Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for(int i = 2; i < m; i += 2)
{
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0)
{
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost = min(min_cost,
m / i +
minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver code
int main()
{
int M = 6;
int N = 24;
// Function call
int minimum_cost = minSteps(M, N);
// If conversion is
// not possible
if (minimum_cost == inf)
minimum_cost = -1;
// Print the cost
cout << minimum_cost;
return 0;
}
// This code is contributed by akhilsaini
Java
// Java program for the above approach
import java.util.*;
public class GFG {
static int inf = 1000000008;
// Function to find the value of
// minimum steps to convert m to n
public static int
minSteps(int m, int n)
{
// Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for (int i = 2; i < m; i += 2) {
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0) {
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost
= Math.min(
min_cost,
m / i
+ minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver Code
public static void
main(String args[])
{
int M = 6;
int N = 24;
// Function Call
int minimum_cost
= minSteps(M, N);
// If conversion is
// not possible
minimum_cost
= minimum_cost
== inf
? -1
: minimum_cost;
// Print the cost
System.out.println(minimum_cost);
}
}
Python3
# Python3 program for the above approach
inf = 1000000008
# Function to find the value of
# minimum steps to convert m to n
def minSteps(m, n):
# Base Case
if (n == m):
return 0
# If n exceeds m
if (m > n):
return inf
min_cost = inf
# Iterate through all possible
# even divisors of m
for i in range(2, m, 2):
# If m is divisible by i,
# then find the minimum cost
if (m % i == 0):
# Add the cost to convert
# m to m+i and recursively
# call next state
min_cost = min(min_cost, m / i +
minSteps(m + i, n))
# Return min_cost
return min_cost
# Driver Code
if __name__ == '__main__':
M = 6
N = 24
# Function call
minimum_cost = minSteps(M, N)
# If conversion is
# not possible
if minimum_cost == inf:
minimum_cost = -1
# Print the cost
print(minimum_cost)
# This code is contributed by mohit kumar 29
C#
// C# program for the above approach
using System;
class GFG{
static int inf = 1000000008;
// Function to find the value of
// minimum steps to convert m to n
public static int minSteps(int m,
int n)
{
// Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for (int i = 2; i < m; i += 2)
{
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0)
{
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost = Math.Min(min_cost, m / i +
minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver Code
public static void Main(String []args)
{
int M = 6;
int N = 24;
// Function Call
int minimum_cost = minSteps(M, N);
// If conversion is
// not possible
minimum_cost = minimum_cost == inf ? -1 :
minimum_cost;
// Print the cost
Console.WriteLine(minimum_cost);
}
}
// This code is contributed by Rajput-Ji
C++
// C++ program for the above approach
#include
using namespace std;
int inf = 1000000008;
// Utility function to calculate the
// minimum cost
int minStepsUtil(int m, int n, int dp[])
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for(int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = min(min_cost,
m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
void minSteps(int M, int N)
{
// Initialise the dp array
// with infinity
int dp[N + 5];
for(int i = 0; i < N + 5; i++)
{
dp[i] = inf;
}
// Function call
int minimum_cost = minStepsUtil(M, N, dp);
if (minimum_cost == inf)
minimum_cost = -1;
// Print the minimum cost
cout << minimum_cost;
}
// Driver code
int main()
{
int M = 6;
int N = 24;
// Function call
minSteps(M, N);
}
// This code is contributed by akhilsaini
Java
// Java program for the above approach
import java.util.*;
public class GFG {
static int inf = 1000000008;
// Utility function to calculate the
// minimum cost
public static int
minStepsUtil(int m, int n, int dp[])
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for (int i = 2; i < m; i += 2) {
if (m % i == 0) {
min_cost = Math.min(
min_cost,
m / i
+ minStepsUtil(m + i, n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void
minSteps(int M, int N)
{
// Initialise the dp array
// with infinity
int dp[] = new int[N + 5];
Arrays.fill(dp, inf);
// Function Call
int minimum_cost
= minStepsUtil(M, N, dp);
minimum_cost
= minimum_cost
== inf
? -1
: minimum_cost;
// Print the minimum cost
System.out.println(minimum_cost);
}
// Driver code
public static void main(String args[])
{
int M = 6;
int N = 24;
// Function Call
minSteps(M, N);
}
}
C#
// C# program for the above approach
using System;
class GFG{
static int inf = 1000000008;
// Utility function to calculate the
// minimum cost
public static int minStepsUtil(int m,
int n, int []dp)
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for (int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = Math.Min(min_cost, m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void minSteps(int M,
int N)
{
// Initialise the dp array
// with infinity
int []dp = new int[N + 5];
for(int i = 0; i < dp.GetLength(0);
i++)
dp[i] = inf;
// Function Call
int minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = minimum_cost ==
inf ? -1 : minimum_cost;
// Print the minimum cost
Console.WriteLine(minimum_cost);
}
// Driver code
public static void Main(String []args)
{
int M = 6;
int N = 24;
// Function Call
minSteps(M, N);
}
}
// This code is contributed by 29AjayKumar
Python3
# Python program for the above approach
inf = 1000000008;
# Utility function to calculate the
# minimum cost
def minStepsUtil(m, n, dp):
# Positive base case
if (n == m):
return 0;
# Negative base case
if (m > n):
return inf;
# If current state is already
# computed then return the
# current state value
if (dp[m] != inf):
return dp[m];
min_cost = inf;
# Iterate through all possible
# even divisors
for i in range(2,m,2):
if (m % i == 0):
min_cost = min(min_cost, m // i + minStepsUtil(m + i, n, dp));
# Store the precomputed answer
dp[m] = min_cost
return dp[m];
def minSteps(M, N):
# Initialise the dp array
# with infinity
dp = [inf]*(N + 5);
# Function Call
minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = -1 if minimum_cost == inf else minimum_cost;
# Prthe minimum cost
print(minimum_cost);
# Driver code
if __name__ == '__main__':
M = 6;
N = 24;
# Function Call
minSteps(M, N);
# This code contributed by shikhasingrajput
10
时间复杂度: O(2 N )
辅助空间: O(1)
高效的方法:可以通过对上述实现使用动态编程和备注来优化上述方法。不必一次又一次地计算状态,而是将其存储在数组dp []中,并在需要时使用它。
dp(m) = min(dp(m), (m/i) + dp(m+i)) for all even divisors of m less than m
下面是上述方法的实现:
C++
// C++ program for the above approach
#include
using namespace std;
int inf = 1000000008;
// Utility function to calculate the
// minimum cost
int minStepsUtil(int m, int n, int dp[])
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for(int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = min(min_cost,
m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
void minSteps(int M, int N)
{
// Initialise the dp array
// with infinity
int dp[N + 5];
for(int i = 0; i < N + 5; i++)
{
dp[i] = inf;
}
// Function call
int minimum_cost = minStepsUtil(M, N, dp);
if (minimum_cost == inf)
minimum_cost = -1;
// Print the minimum cost
cout << minimum_cost;
}
// Driver code
int main()
{
int M = 6;
int N = 24;
// Function call
minSteps(M, N);
}
// This code is contributed by akhilsaini
Java
// Java program for the above approach
import java.util.*;
public class GFG {
static int inf = 1000000008;
// Utility function to calculate the
// minimum cost
public static int
minStepsUtil(int m, int n, int dp[])
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for (int i = 2; i < m; i += 2) {
if (m % i == 0) {
min_cost = Math.min(
min_cost,
m / i
+ minStepsUtil(m + i, n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void
minSteps(int M, int N)
{
// Initialise the dp array
// with infinity
int dp[] = new int[N + 5];
Arrays.fill(dp, inf);
// Function Call
int minimum_cost
= minStepsUtil(M, N, dp);
minimum_cost
= minimum_cost
== inf
? -1
: minimum_cost;
// Print the minimum cost
System.out.println(minimum_cost);
}
// Driver code
public static void main(String args[])
{
int M = 6;
int N = 24;
// Function Call
minSteps(M, N);
}
}
C#
// C# program for the above approach
using System;
class GFG{
static int inf = 1000000008;
// Utility function to calculate the
// minimum cost
public static int minStepsUtil(int m,
int n, int []dp)
{
// Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for (int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = Math.Min(min_cost, m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void minSteps(int M,
int N)
{
// Initialise the dp array
// with infinity
int []dp = new int[N + 5];
for(int i = 0; i < dp.GetLength(0);
i++)
dp[i] = inf;
// Function Call
int minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = minimum_cost ==
inf ? -1 : minimum_cost;
// Print the minimum cost
Console.WriteLine(minimum_cost);
}
// Driver code
public static void Main(String []args)
{
int M = 6;
int N = 24;
// Function Call
minSteps(M, N);
}
}
// This code is contributed by 29AjayKumar
Python3
# Python program for the above approach
inf = 1000000008;
# Utility function to calculate the
# minimum cost
def minStepsUtil(m, n, dp):
# Positive base case
if (n == m):
return 0;
# Negative base case
if (m > n):
return inf;
# If current state is already
# computed then return the
# current state value
if (dp[m] != inf):
return dp[m];
min_cost = inf;
# Iterate through all possible
# even divisors
for i in range(2,m,2):
if (m % i == 0):
min_cost = min(min_cost, m // i + minStepsUtil(m + i, n, dp));
# Store the precomputed answer
dp[m] = min_cost
return dp[m];
def minSteps(M, N):
# Initialise the dp array
# with infinity
dp = [inf]*(N + 5);
# Function Call
minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = -1 if minimum_cost == inf else minimum_cost;
# Prthe minimum cost
print(minimum_cost);
# Driver code
if __name__ == '__main__':
M = 6;
N = 24;
# Function Call
minSteps(M, N);
# This code contributed by shikhasingrajput
10
时间复杂度: O(Nlog(M))
辅助空间: O(N)