<p>We have two arrays <code>arr1</code> and <code>arr2</code> which are initially empty. You need to add positive integers to them such that they satisfy all the following conditions:</p>

<ul>
	<li><code>arr1</code> contains <code>uniqueCnt1</code> <strong>distinct</strong> positive integers, each of which is <strong>not divisible</strong> by <code>divisor1</code>.</li>
	<li><code>arr2</code> contains <code>uniqueCnt2</code> <strong>distinct</strong> positive integers, each of which is <strong>not divisible</strong> by <code>divisor2</code>.</li>
	<li><strong>No</strong> integer is present in both <code>arr1</code> and <code>arr2</code>.</li>
</ul>

<p>Given <code>divisor1</code>, <code>divisor2</code>, <code>uniqueCnt1</code>, and <code>uniqueCnt2</code>, return <em>the <strong>minimum possible maximum</strong> integer that can be present in either array</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> divisor1 = 2, divisor2 = 7, uniqueCnt1 = 1, uniqueCnt2 = 3
<strong>Output:</strong> 4
<strong>Explanation:</strong> 
We can distribute the first 4 natural numbers into arr1 and arr2.
arr1 = [1] and arr2 = [2,3,4].
We can see that both arrays satisfy all the conditions.
Since the maximum value is 4, we return it.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1
<strong>Output:</strong> 3
<strong>Explanation:</strong> 
Here arr1 = [1,2], and arr2 = [3] satisfy all conditions.
Since the maximum value is 3, we return it.</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> divisor1 = 2, divisor2 = 4, uniqueCnt1 = 8, uniqueCnt2 = 2
<strong>Output:</strong> 15
<strong>Explanation:</strong> 
Here, the final possible arrays can be arr1 = [1,3,5,7,9,11,13,15], and arr2 = [2,6].
It can be shown that it is not possible to obtain a lower maximum satisfying all conditions. 
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>2 &lt;= divisor1, divisor2 &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= uniqueCnt1, uniqueCnt2 &lt; 10<sup>9</sup></code></li>
	<li><code>2 &lt;= uniqueCnt1 + uniqueCnt2 &lt;= 10<sup>9</sup></code></li>
</ul>

def enough(max, divisor1: int, divisor2: int, uniqueCnt1: int, uniqueCnt2: int, lcm: int) -> bool:
    notIn1 = max // divisor1
    notIn2 = max // divisor2
    in1 = max - notIn1
    in2 = max - notIn2
    inNeither = max // lcm
    inBoth = max - (notIn1 + notIn2 - inNeither)
    if in1 < uniqueCnt1 or in2 < uniqueCnt2:
        return False
    inOnly1 = in1 - inBoth
    if uniqueCnt1 > inOnly1:
        in2 -= uniqueCnt1 - inOnly1
    return in2 >= uniqueCnt2

def getGcd(a, b):
    if a > b:
        a, b = b, a
    while b % a > 0:
        a, b = b % a, a
    return a

def getLcm(a, b):
    return a * (b // getGcd(a, b))

def getSingleCount(divisor, cnt):
    # each chunk of divisor has divisor - 1 valid numbers.
    return (cnt * divisor + divisor - 2) // (divisor - 1)

class Solution:
    def minimizeSet(self, divisor1: int, divisor2: int, uniqueCnt1: int, uniqueCnt2: int) -> int:
        a = uniqueCnt1 + uniqueCnt2
        b = getSingleCount(divisor1, uniqueCnt1) + getSingleCount(divisor2, uniqueCnt2)
        lcm = getLcm(divisor1, divisor2)
        while a < b:
            m = (a + b) // 2
            if enough(m, divisor1, divisor2, uniqueCnt1, uniqueCnt2, lcm):
                b = m
            else:
                a = m + 1
        return b
41