g1201_1300.s1201_ugly_number_iii.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g1201_1300.s1201_ugly_number_iii;

// #Medium #Math #Binary_Search #Number_Theory #Binary_Search_II_Day_20
// #2022_03_08_Time_0_ms_(100.00%)_Space_41.8_MB_(7.39%)

/**
 * 1201 - Ugly Number III\.
 *
 * Medium
 *
 * An **ugly number** is a positive integer that is divisible by `a`, `b`, or `c`.
 *
 * Given four integers `n`, `a`, `b`, and `c`, return the n^th **ugly number**.
 *
 * **Example 1:**
 *
 * **Input:** n = 3, a = 2, b = 3, c = 5
 *
 * **Output:** 4
 *
 * **Explanation:** The ugly numbers are 2, 3, 4, 5, 6, 8, 9, 10... The 3^rd is 4.
 *
 * **Example 2:**
 *
 * **Input:** n = 4, a = 2, b = 3, c = 4
 *
 * **Output:** 6
 *
 * **Explanation:** The ugly numbers are 2, 3, 4, 6, 8, 9, 10, 12... The 4^th is 6.
 *
 * **Example 3:**
 *
 * **Input:** n = 5, a = 2, b = 11, c = 13
 *
 * **Output:** 10
 *
 * **Explanation:** The ugly numbers are 2, 4, 6, 8, 10, 11, 12, 13... The 5^th is 10.
 *
 * **Constraints:**
 *
 * *   1 <= n, a, b, c <= 10⁹
 * *   1 <= a * b * c <= 10¹⁸
 * *   It is guaranteed that the result will be in range [1, 2 * 10⁹].
**/
public class Solution {

    private long getLcm(long a, long b) {
        long mx = a;
        long mn = b;
        if (a < b) {
            mx = b;
            mn = a;
        }
        while (mn != 0) {
            long tmp = mn;
            mn = mx % mn;
            mx = tmp;
        }
        return (a * b) / mx;
    }

    public int nthUglyNumber(int n, int a, int b, int c) {
        long ab = getLcm(a, b);
        long ac = getLcm(a, c);
        long bc = getLcm(b, c);
        long abc = getLcm(a, bc);

        long left = 1;
        long right = 2000000001;
        if (a != 0 && b != 0 && c != 0 && bc != 0) {
            while (left < right) {
                long mid = left + (right - left) / 2;
                if (mid / a + mid / b + mid / c - mid / ab - mid / ac - mid / bc + mid / abc >= n) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            }
        }
        return (int) left;
    }
}