Related Articles

# Maximize profit when divisibility by two numbers have associated profits

• Last Updated : 27 Apr, 2021

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

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

 ``

## Javascript

 ``
Output:
`12` My Personal Notes arrow_drop_up