Given five integers N, A, B, X and Y. The task is to find the maximum profit obtained from the numbers from the range [1, N]. If a positive number is divisible by A then the profit increases by X and if a positive number is divisible by B then the profit increases by Y.
Note: Profit from a positive number can be added at most once.
Examples:
Input: N = 3, A = 1, B = 2, X = 3, Y = 4
Output: 10
1, 2 and 3 are divisible by A.
2 is the only number in the given range which is divisible by B.
2 is divisible by both A and B.
1 and 3 can be divided by A to get the profit of 2 * 3 = 6
2 can be divided by B to get the profit of 1 * 4 = 4
2 is divisible by both but in order to maximise the profit it is divided by B instead of A.Input: N = 6, A = 6, B = 2, X = 8, Y = 2
Output: 12
Naive approach: Iterate over all the numbers from 1 to N, and for each number check if it is divisible by A or B, and add the corresponding profit X or Y to the total profit. However, since profit can be added at most once, we also need to keep track of which numbers have already been considered and added to the profit.
Steps to implement the above approach:
- Initialize the total profit to 0.
- If i is divisible by A and has not already been considered, add X to the total profit and mark i as considered.
- If i is divisible by B and has not already been considered, add Y to the total profit and mark i as considered.
- Return the total profit.
Below is the implementation of the above approach:
#include <bits/stdc++.h> using namespace std;
// Function to return the maximum profit int maxProfit( int n, int a, int b, int x, int y)
{ int profit = 0;
for ( int i = 1; i <= n; i++) {
if (i % a == 0 && i % b == 0) {
profit += max(x, y);
}
else if (i % a == 0) {
profit += x;
}
else if (i % b == 0) {
profit += y;
}
}
return profit;
} // Driver code int main()
{ int n = 6, a = 6, b = 2, x = 8, y = 2;
cout << maxProfit(n, a, b, x, y);
return 0;
} |
public class Main {
// Function to return the maximum profit
public static int maxProfit( int n, int a, int b, int x,
int y)
{
int profit = 0 ;
for ( int i = 1 ; i <= n; i++) {
if (i % a == 0 && i % b == 0 ) {
profit += Math.max(x, y);
}
else if (i % a == 0 ) {
profit += x;
}
else if (i % b == 0 ) {
profit += y;
}
}
return profit;
}
// Driver code
public static void main(String[] args)
{
int n = 6 , a = 6 , b = 2 , x = 8 , y = 2 ;
System.out.println(maxProfit(n, a, b, x, y));
}
} |
# Function to return the maximum profit def maxProfit(n, a, b, x, y):
profit = 0
for i in range ( 1 , n + 1 ):
if i % a = = 0 and i % b = = 0 :
profit + = max (x, y)
elif i % a = = 0 :
profit + = x
elif i % b = = 0 :
profit + = y
return profit
# Driver code if __name__ = = '__main__' :
n = 6
a = 6
b = 2
x = 8
y = 2
print (maxProfit(n, a, b, x, y))
|
using System;
public class Program {
// Function to return the maximum profit
public static int MaxProfit( int n, int a, int b, int x,
int y)
{
int profit = 0;
for ( int i = 1; i <= n; i++) {
if (i % a == 0 && i % b == 0) {
profit += Math.Max(x, y);
}
else if (i % a == 0) {
profit += x;
}
else if (i % b == 0) {
profit += y;
}
}
return profit;
}
// Driver code
public static void Main()
{
int n = 6, a = 6, b = 2, x = 8, y = 2;
Console.WriteLine(MaxProfit(n, a, b, x, y));
}
} |
// Function to return the maximum profit function maxProfit(n, a, b, x, y) {
let profit = 0;
for (let i = 1; i <= n; i++) {
if (i % a === 0 && i % b === 0) {
profit += Math.max(x, y);
} else if (i % a === 0) {
profit += x;
} else if (i % b === 0) {
profit += y;
}
}
return profit;
} // Driver code const n = 6, a = 6, b = 2, x = 8, y = 2;
console.log(maxProfit(n, a, b, x, y));
|
12
Time Complexity: O(n) where n is the value of N provided in the input.
Auxiliary Space: O(1)
Approach: Easy to see that we can divide a number with both A and B only if the number is a multiple of lcm(A, B). Obviously, that number should be divided with the number that gives more profit.
So the answer equals to X * (N / A) + Y * (N / B) – min(X, Y) * (N / lcm(A, B)).
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the maximum profit int maxProfit( int n, int a, int b, int x, int y)
{ int res = x * (n / a);
res += y * (n / b);
// min(x, y) * n / lcm(a, b)
res -= min(x, y) * (n / ((a * b) / __gcd(a, b)));
return res;
} // Driver code int main()
{ int n = 6, a = 6, b = 2, x = 8, y = 2;
cout << maxProfit(n, a, b, x, y);
return 0;
} |
// Java implementation of the approach class GFG
{ static int __gcd( int a, int b)
{ if (b == 0 )
return a;
return __gcd(b, a % b);
} // Function to return the maximum profit static int maxProfit( int n, int a, int b,
int x, int y)
{ int res = x * (n / a);
res += y * (n / b);
// min(x, y) * n / lcm(a, b)
res -= Math.min(x, y) * (n / ((a * b) / __gcd(a, b)));
return res;
} // Driver code public static void main (String[] args)
{ int n = 6 , a = 6 , b = 2 , x = 8 , y = 2 ;
System.out.println(maxProfit(n, a, b, x, y));
} } // This code is contributed by mits |
# Python3 implementation of the approach from math import gcd
# Function to return the maximum profit def maxProfit(n, a, b, x, y) :
res = x * (n / / a);
res + = y * (n / / b);
# min(x, y) * n / lcm(a, b)
res - = min (x, y) * (n / / ((a * b) / /
gcd(a, b)));
return res;
# Driver code if __name__ = = "__main__" :
n = 6 ;a = 6 ; b = 2 ; x = 8 ; y = 2 ;
print (maxProfit(n, a, b, x, y));
# This code is contributed by Ryuga |
// C# implementation of the approach using System;
class GFG
{ static int __gcd( int a, int b)
{ if (b == 0)
return a;
return __gcd(b, a % b);
} // Function to return the maximum profit static int maxProfit( int n, int a, int b, int x, int y)
{ int res = x * (n / a);
res += y * (n / b);
// min(x, y) * n / lcm(a, b)
res -= Math.Min(x, y) * (n / ((a * b) / __gcd(a, b)));
return res;
} // Driver code static void Main()
{ int n = 6, a = 6, b = 2, x = 8, y = 2;
Console.WriteLine(maxProfit(n, a, b, x, y));
} } // This code is contributed by mits |
<script> // JavaScript implementation of the approach function __gcd(a, b)
{ if (b == 0)
return a;
return __gcd(b, a % b);
} // Function to return the maximum profit function maxProfit(n, a, b, x, y)
{ let res = x * Math.floor(n / a);
res += y * Math.floor(n / b);
// min(x, y) * n / lcm(a, b)
res -= Math.min(x, y) * (n / ((a * b) / __gcd(a, b)));
return res;
} // Driver code let n = 6, a = 6, b = 2, x = 8, y = 2;
document.write(maxProfit(n, a, b, x, y));
// </script> |
<?php // PHP implementation of the approach function __gcd( $a , $b )
{ if ( $b == 0)
return $a ;
return __gcd( $b , $a % $b );
} // Function to return the maximum profit function maxProfit( $n , $a , $b , $x , $y )
{ $res = $x * ( $n / $a );
$res += $y * ( $n / $b );
// min(x, y) * n / lcm(a, b)
$res -= min( $x , $y ) * ( $n /
(( $a * $b ) / __gcd( $a , $b )));
return $res ;
} // Driver code $n = 6;
$a = 6;
$b = 2;
$x = 8;
$y = 2;
print (maxProfit( $n , $a , $b , $x , $y ));
// This code is contributed by mits ?> |
12
Time Complexity: O(log(min(a, b)))
Auxiliary Space: O(log(min(a, b)))