丑数系列算法详解
描述
最近读者群里有个读者跟我私信，说去面试微软遇到了一系列和数学相关的算法题，直接懵圈了。我看了下题目，发现这些题其实就是 LeetCode 上面「丑数」系列问题的修改版。
首先，「丑数」系列问题属于会者不难难者不会的类型，因为会用到些数学定理嘛，如果没有专门学过，靠自己恐怕是想不出来的。
另外，这类问题而且非常考察抽象联想能力，因为它除了数学定理之外，还需要你把题目抽象成链表相关的题目运用双指针技巧，或者抽象成数组相关的题目运用二分搜索技巧。
那么今天我就来用一篇文章把所有丑数相关的问题一网打尽，看看这类问题能够如何变化，应该如何解决。
丑数 I
首先是力扣第 263 题「丑数」，题目给你输入一个数字n，请你判断n是否为「丑数」。所谓「丑数」，就是只包含质因数2、3和5的正整数。
函数签名如下：
boolean isUgly(int n)
比如 12 = 2 x 2 x 3 就是一个丑数，而 42 = 2 x 3 x 7 就不是一个丑数。
这道题其实非常简单，前提是你知道算术基本定理（正整数唯一分解定理）：
任意一个大于 1 的自然数，要么它本身就是质数，要么它可以分解为若干质数的乘积。
既然任意一个大于一的正整数都可以分解成若干质数的乘积，那么丑数也可以被分解成若干质数的乘积，且这些质数只能是 2, 3 或 5。
有了这个思路，就可以实现isUgly函数了：
public boolean isUgly(int n) {
if (n <= 0) return false;
// 如果 n 是丑数，分解因子应该只有 2, 3, 5
while (n % 2 == 0) n /= 2;
while (n % 3 == 0) n /= 3;
while (n % 5 == 0) n /= 5;
// 如果能够成功分解，说明是丑数
return n == 1;
}
丑数 II
接下来提升难度，看下力扣第 264 题「丑数 II」，现在题目不是让你判断一个数是不是丑数，而是给你输入一个n，让你计算第n个丑数是多少，函数签名如下：
int nthUglyNumber(int n)
比如输入n = 10，函数应该返回 12，因为从小到大的丑数序列为1, 2, 3, 4, 5, 6, 8, 9, 10, 12，第 10 个丑数是 12（注意我们把 1 也算作一个丑数）。
这道题很精妙，你看着它好像是道数学题，实际上它却是一个合并多个有序链表的问题，同时用到了筛选素数的思路。
首先，我在前文 如何高效寻找质数 中也讲过高效筛选质数的「筛数法」：一个质数和除 1 以外的其他数字的乘积一定不是质数，把这些数字筛掉，剩下的就是质数。
Wikipedia 的这幅图很形象：
基于筛数法的思路和丑数的定义，我们不难想到这样一个规律：如果一个数x是丑数，那么x * 2, x * 3, x * 5都一定是丑数。
如果我们把所有丑数想象成一个从小到大排序的链表，就是这个样子：
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 8 -> ...
然后，我们可以把丑数分为三类：2 的倍数、3 的倍数、5 的倍数。这三类丑数就好像三条有序链表，如下：
能被 2 整除的丑数：
1*2 -> 2*2 -> 3*2 -> 4*2 -> 5*2 -> 6*2 -> 8*2 ->...
能被 3 整除的丑数：
1*3 -> 2*3 -> 3*3 -> 4*3 -> 5*3 -> 6*3 -> 8*3 ->...
能被 5 整除的丑数：
1*5 -> 2*5 -> 3*5 -> 4*5 -> 5*5 -> 6*5 -> 8*5 ->...
我们如果把这三条「有序链表」合并在一起并去重，得到的就是丑数的序列，其中第n个元素就是题目想要的答案：
1 -> 1*2 -> 1*3 -> 2*2 -> 1*5 -> 3*2 -> 4*2 ->...
所以这里就和 链表双指针技巧汇总 中讲到的合并两条有序链表的思路基本一样了，先看下合并有序链表的核心解法代码：
ListNode mergeTwoLists(ListNode l1, ListNode l2) {
// 虚拟头结点存储结果链表，p 指针指向结果链表
ListNode dummy = new ListNode(-1), p = dummy;
// p1, p2 分别在两条有序链表上
ListNode p1 = l1, p2 = l2;
while (p1 != null && p2 != null) {
// 比较 p1 和 p2 两个指针
// 将值较小的的节点接到结果链表
if (p1.val > p2.val) {
p.next = p2;
p2 = p2.next;
} else {
p.next = p1;
p1 = p1.next;
}
// p 指针不断前进
p = p.next;
}
// 省略部分非核心代码...
}
对于这道题，我们抽象出三条有序的丑数链表，合并这三条有序链表得到的结果就是丑数序列，其中第n个丑数就是题目想要的答案。
类比合并两个有序链表，看下这道题的解法代码：
int nthUglyNumber(int n) {
// 可以理解为三个指向有序链表头结点的指针
int p2 = 1, p3 = 1, p5 = 1;
// 可以理解为三个有序链表的头节点的值
int product2 = 1, product3 = 1, product5 = 1;
// 可以理解为最终合并的有序链表（结果链表）
int[] ugly = new int[n + 1];
// 可以理解为结果链表上的指针
int p = 1;
// 开始合并三个有序链表，找到第 n 个丑数时结束
while (p <= n) {
// 取三个链表的最小结点
int min = Math.min(Math.min(product2, product3), product5);
// 将最小节点接到结果链表上
ugly[p] = min;
p++;
// 前进对应有序链表上的指针
if (min == product2) {
product2 = 2 * ugly[p2];
p2++;
}
if (min == product3) {
product3 = 3 * ugly[p3];
p3++;
}
if (min == product5) {
product5 = 5 * ugly[p5];
p5++;
}
}
// 返回第 n 个丑数
return ugly[n];
}
我们用p2, p3, p5分别代表三条丑数链表上的指针，用product2, product3, product5代表丑数链表上节点的值，用ugly数组记录有序链表合并之后的结果。
有了之前的铺垫和类比，你应该很容易看懂这道题的思路了，接下来我们再提高一点难度。
超级丑数
看下力扣第 313 题「超级丑数」，这道题给你输入一个质数列表primes和一个正整数n，请你计算第n个「超级丑数」。所谓超级丑数是一个所有质因数都出现在primes中的正整数，函数签名如下：
int nthSuperUglyNumber(int n, int[] primes)
如果让primes = [2, 3, 5]就是上道题，所以这道题是上道题的进阶版。
不过思路还是类似的，你还是把每个质因子看做一条有序链表，上道题相当于让你合并三条有序链表，而这道题相当于让你合并len(primes)条有序链表，也就是 双指针技巧秒杀七道链表题目 中讲过的「合并 K 条有序链表」的思路。
注意我们在上道题抽象出了三条链表，需要p2, p3, p5作为三条有序链表上的指针，同时需要product2, product3, product5记录指针所指节点的值，每次循环用min函数计算最小头结点。
这道题相当于输入了len(primes)条有序链表，我们不能用min函数计算最小头结点了，而是要用优先级队列来计算最小头结点，同时依然要维护链表指针、指针所指节点的值，我们可以用一个三元组来保存这些信息。
你结合 双指针技巧秒杀七道链表题目 合并 K 条有序链表的思路就能理解这道题的解法：
int nthSuperUglyNumber(int n, int[] primes) {
// 优先队列中装三元组 int[] {product, prime, pi}
// 其中 product 代表链表节点的值，prime 是计算下一个节点所需的质数因子，pi 代表链表上的指针
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> {
// 优先级队列按照节点的值排序
return a[0] - b[0];
});
// 把多条链表的头结点加入优先级队列
for (int i = 0; i < primes.length; i++) {
pq.offer(new int[]{ 1, primes[i], 1 });
}
// 可以理解为最终合并的有序链表（结果链表）
int[] ugly = new int[n + 1];
// 可以理解为结果链表上的指针
int p = 1;
while (p <= n) {
// 取三个链表的最小结点
int[] pair = pq.poll();
int product = pair[0];
int prime = pair[1];
int index = pair[2];
// 避免结果链表出现重复元素
if (product != ugly[p - 1]) {
// 接到结果链表上
ugly[p] = product;
p++;
}
// 生成下一个节点加入优先级队列
int[] nextPair = new int[]{ugly[index] * prime, prime, index + 1};
pq.offer(nextPair);
}
return ugly[n];
}
接下来看下第四道丑数题目，也是今天的压轴题。
丑数 III
这是力扣第 1201 题「丑数 III」，看下题目：
给你四个整数：n, a, b, c，请你设计一个算法来找出第n个丑数。其中丑数是可以被a或b或c整除的正整数。
这道题和之前题目的不同之处在于它改变了「丑数」的定义，只要一个正整数x存在a, b, c中的任何一个因子，那么x就是丑数。
比如输入n = 7, a = 3, b = 4, c = 5，那么算法输出 10，因为符合条件的丑数序列为3, 4, 5, 6, 8, 9, 10, ...，其中第 7 个数字是 10。
有了之前几道题的铺垫，你肯定可以想到把a, b, c的倍数抽象成三条有序链表：
1*3 -> 2*3 -> 3*3 -> 4*3 -> 5*3 -> 6*3 -> 7*3 ->...
1*4 -> 2*4 -> 3*4 -> 4*4 -> 5*4 -> 6*4 -> 7*4 ->...
1*5 -> 2*5 -> 3*5 -> 4*5 -> 5*5 -> 6*5 -> 7*5 ->...
然后将这三条链表合并成一条有序链表并去除重复元素，这样合并后的链表元素就是丑数序列，我们从中找到第n个元素即可：
1*3 -> 1*4 -> 1*5 -> 2*3 -> 2*4 -> 3*3 -> 2*5 ->...
有了这个思路，可以直接写出代码：
public int nthUglyNumber(int n, int a, int b, int c) {
// 可以理解为三个有序链表的头结点的值
// 由于数据规模较大，用 long 类型
long productA = a, productB = b, productC = c;
// 可以理解为合并之后的有序链表上的指针
int p = 1;
long min = -666;
// 开始合并三个有序链表，获取第 n 个节点的值
while (p <= n) {
// 取三个链表的最小结点
min = Math.min(Math.min(productA, productB), productC);
p++;
// 前进最小结点对应链表的指针
if (min == productA) {
productA += a;
}
if (min == productB) {
productB += b;
}
if (min == productC) {
productC += c;
}
}
return (int) min;
}
这个思路应该是非常简单的，但是提交之后并不能通过所有测试用例，会超时。
注意题目给的数据范围非常大，a, b, c, n的大小可以达到 10^9，所以即便上述算法的时间复杂度是O(n)，也是相对比较耗时的，应该有更好的思路能够进一步降低时间复杂度。
这道题的正确解法难度比较大，难点在于你要把一些数学知识和 二分搜索技巧 结合起来才能高效解决这个问题。
首先，我们可以定义一个单调递增的函数f：
f(num, a, b, c)计算[1..num]中，能够整除a或b或c的数字的个数，显然函数f的返回值是随着num的增加而增加的（单调递增）。
题目让我们求第n个能够整除a或b或c的数字是什么，也就是说我们要找到一个最小的num，使得f(num, a, b, c) == n。
这个num就是第n个能够整除a或b或c的数字。
根据 二分查找的实际运用 给出的思路模板，我们得到一个单调函数f，想求参数num的最小值，就可以运用搜索左侧边界的二分查找算法了：
int nthUglyNumber(int n, int a, int b, int c) {
// 题目说本题结果在 [1, 2 * 10^9] 范围内，
// 所以就按照这个范围初始化两端都闭的搜索区间
int left = 1, right = (int) 2e9;
// 搜索左侧边界的二分搜索
while (left <= right) {
int mid = left + (right - left) / 2;
if (f(mid, a, b, c) < n) {
// [1..mid] 中符合条件的元素个数不足 n，所以目标在右半边
left = mid + 1;
} else {
// [1..mid] 中符合条件的元素个数大于 n，所以目标在左半边
right = mid - 1;
}
}
return left;
}
// 函数 f 是一个单调函数
// 计算 [1..num] 之间有多少个能够被 a 或 b 或 c 整除的数字
long f(int num, int a, int b, int c) {
// 下文实现
}
搜索左侧边界的二分搜索代码模板在 二分查找框架详解 中讲过，没啥可说的，关键说一下函数f怎么实现，这里面涉及容斥原理以及最小公因数、最小公倍数的计算方法。
首先，我把[1..num]中能够整除a的数字归为集合A，能够整除b的数字归为集合B，能够整除c的数字归为集合C，那么len(A) = num / a, len(B) = num / b, len(C) = num / c，这个很好理解。
但是f(num, a, b, c)的值肯定不是num / a + num / b + num / c这么简单，因为你注意有些数字可能可以被a, b, c中的两个数或三个数同时整除，如下图：
按照容斥原理，这个集合中的元素应该是：A + B + C - A ∩ B - A ∩ C - B ∩ C + A ∩ B ∩ C。结合上图应该很好理解。
问题来了，A, B, C三个集合的元素个数我们已经算出来了，但如何计算像A ∩ B这种交集的元素个数呢？
其实也很容易想明白，A ∩ B的元素个数就是num / lcm(a, b)，其中lcm是计算最小公倍数（Least Common Multiple）的函数。
类似的，A ∩ B ∩ C的元素个数就是num / lcm(lcm(a, b), c)的值。
现在的问题是，最小公倍数怎么求？
直接记住定理吧：lcm(a, b) = a * b / gcd(a, b)，其中gcd是计算最大公因数（Greatest Common Divisor）的函数。
现在的问题是，最大公因数怎么求？这应该是经典算法了，我们一般叫辗转相除算法（或者欧几里得算法）。
好了，套娃终于套完了，我们可以把上述思路翻译成代码就可以实现f函数，注意本题数据规模比较大，有时候需要用long类型防止int溢出：
// 计算最大公因数（辗转相除/欧几里得算法）
long gcd(long a, long b) {
if (a < b) {
// 保证 a > b
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
// 最小公倍数
long lcm(long a, long b) {
// 最小公倍数就是乘积除以最大公因数
return a * b / gcd(a, b);
}
// 计算 [1..num] 之间有多少个能够被 a 或 b 或 c 整除的数字
long f(int num, int a, int b, int c) {
long setA = num / a, setB = num / b, setC = num / c;
long setAB = num / lcm(a, b);
long setAC = num / lcm(a, c);
long setBC = num / lcm(b, c);
long setABC = num / lcm(lcm(a, b), c);
// 集合论定理：A + B + C - A ∩ B - A ∩ C - B ∩ C + A ∩ B ∩ C
return setA + setB + setC - setAB - setAC - setBC + setABC;
}
实现了f函数，结合之前的二分搜索模板，时间复杂度下降到对数级别，即可高效解决这道题目了。
以上就是所有「丑数」相关的题目，用到的知识点有算术基本定理、容斥原理、辗转相除法、链表双指针合并有序链表、二分搜索模板等等。
如果没做过类似的题目可能很难想出来，但只要做过，也就手到擒来了。所以我说这种数学问题属于会者不难，难者不会的类型。
审核编辑：汤梓红
-
改进的变阶数LMS自适应滤波算法2010-05-13 0
-
SVPWM的原理推导和控制算法详解2016-01-28 0
-
详解快速傅里叶变换FFT算法2019-07-18 0
-
算法篇（PID详解)2020-05-19 0
-
详解三电平传统SVPWM调制算法原理2021-08-27 0
-
路由算法详解2009-08-06 5492
-
原码乘法,原码乘法原理详解2010-04-13 33312
-
SVPWM的原理及法则推导和控制算法详解2016-04-13 793
-
PID算法详解2016-12-17 1023
-
基于Labview的PID算法详解2023-03-16 352
-
[源代码]Python算法详解2023-06-06 297
全部0条评论
快来发表一下你的评论吧 !
