Maximize profit when divisibility by two numbers have associated profits

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 // C++ implementation of the approach #include 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

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

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

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

PHP



Output:

12

My Personal Notes arrow_drop_up