[LeetCode][H0878]第 N 个神奇数字（Java）（数学、二分）

题目描述：

如果正整数可以被 A 或 B 整除，那么它是神奇的。

返回第 N 个神奇数字。由于答案可能非常大，返回它模 10^9 + 7 的结果。

示例 1：

输入：N = 1, A = 2, B = 3
输出：2

示例 2：

输入：N = 4, A = 2, B = 3
输出：6

示例 3：

输入：N = 5, A = 2, B = 4
输出：10

示例 4：

输入：N = 3, A = 6, B = 4
输出：8

提示：

1 <= N <= 10^9
2 <= A <= 40000
2 <= B <= 40000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/nth-magical-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

解题思路：

我先说一下 我的思路（数学），有些地方绕了远路，不过还是做出来了。

数学：

与其说是数学，不如说是找规律，
首先要明白，一个 A 与 B 的最小公倍数，是一个循环。假设最小公倍是 abLcm，那么，abLcm+A 一定能被整除，同样的，abLcm+B 也是神奇数字，abLcm+…都是神器数字。所以abLcm是一个循环。
假设 一个循环 内 有个 setcnt 个神奇数字（setcnt=abLcm/A+abLcm/B-1）；
这样 只需要知道 第 N%setcnt 个神奇数字(tempRes) 是多少就好了，那么真正的数字就是 abLcm*(N/setcnt)+ tempRes；
其中 该 mod就mod一下；

这是我的思路，但是 耗时过长 ，用时260ms。就不贴代码了，官方的数学思路和我的基本无差别，

不过在算法实现上，官方使用的技巧更好，
比如在寻找第 N%setcnt 个神奇数字(tempRes) 时，使用滚动数组，节省空间，也节省了排序和二次查找的时间。
官方更好用到了条件，比如N、A、B的取值范围，这就是使得最大的值会比 long 最大值小。所以无需每次都 mod 。
最小公倍数的求法是 比较常用的 算法技巧（最大公约 ——辗转相除法：欧几里得算法）。这个我有用到

看下官方的二分方法吧。

二分：

二分用在 全部数字中寻找 第 N 个神奇数字，
设 f(x) 是 小于等于 x 的神奇数字的个数，那么 f(x) = x/A + x/B - x/abLcm。
x/A 是 小于等于x 被A 整除的个数；
x/B 是 小于等于x 被B 整除的个数；
x/abLcm 是 小于等于x 被AB最小公倍数 整除的个数，也就是 x/A 与 x/B 的交集；

反思错误：

① 要灵活运用条件，条件的判定有时候 比较宽松，比如这次，最大值都比 2⁶¹ -1（Long的最大值） 要小，所以无需过分注意，而我用循环去每次加就MOD，而不是乘法直接乘在MOD。
② 因为我用的数学，在寻找第 N%setcnt 个神奇数字时，用的TreeSet，去重加排序，在寻找那个神奇数字 时，有遍历去寻找，耗时很多。

Java代码：

数学：

class Solution {
	static final long MOD = (long)1e9+7;
    public int nthMagicalNumber(int N, int A, int B) {
        int abLcm = lcm(A,B);
        int setcnt = abLcm/A + abLcm/B - 1;
        int quo = N/setcnt, rem = N%setcnt;

        long ans = (long) quo*abLcm%MOD;
        if (rem == 0)
            return (int) ans;

        int[] heads = new int[]{A, B};
        for (int i=0;i<rem-1;++i) {
            if (heads[0] <= heads[1])
                heads[0] += A;
            else
                heads[1] += B;
        }

        ans += Math.min(heads[0], heads[1]);
        return (int) (ans % MOD);
    }
    int lcm(int a,int b){
        return (a*b)/gcd(a,b);
    }
    int gcd(int a, int b){
        return b==0?a:gcd(b,a%b);
    }
}

二分：

class Solution {
    public int nthMagicalNumber(int N, int A, int B) {
        int MOD = 1_000_000_007;
        int L = A / gcd(A, B) * B;

        long lo = 0;
        long hi = (long) 1e15;
        while (lo < hi) {
            long mi = lo + (hi - lo) / 2;
            // If there are not enough magic numbers below mi...
            if (mi / A + mi / B - mi / L < N)
                lo = mi + 1;
            else
                hi = mi;
        }

        return (int) (lo % MOD);
    }

    public int gcd(int x, int y) {
        if (x == 0) return y;
        return gcd(y % x, x);
    }
}

执行结果：