微软面试题解析:丑数系列算法

Posted 程序员小灰

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了微软面试题解析:丑数系列算法相关的知识,希望对你有一定的参考价值。

读完本文,可以去力扣解决如下题目:

263. 丑数简单

264. 丑数 II中等

1201. 丑数 III中等

313. 超级丑数中等


最近读者群里有个读者跟我私信,说去面试微软遇到了一系列和数学相关的算法题,直接懵圈了。我看了下题目,发现这些题其实就是 LeetCode 上面「丑数」系列问题的修改版。

首先,「丑数」系列问题属于会者不难难者不会的类型,因为会用到些数学定理嘛,如果没有专门学过,靠自己恐怕是想不出来的。

另外,这类问题而且非常考察抽象联想能力,因为它除了数学定理之外,还需要你把题目抽象成链表相关的题目运用双指针技巧,或者抽象成数组相关的题目运用二分搜索技巧。

那么今天我就来用一篇文章把所有丑数相关的问题一网打尽,看看这类问题能够如何变化,应该如何解决。

丑数 I

首先是力扣第 263 题「丑数」,题目给你输入一个数字n,请你判断n是否为「丑数」。所谓「丑数」,就是只包含质因数235的正整数。

函数签名如下:

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个丑数。其中丑数是可以被abc整除的正整数。

这道题和之前题目的不同之处在于它改变了「丑数」的定义,只要一个正整数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]中,能够整除abc的数字的个数,显然函数f的返回值是随着num的增加而增加的(单调递增)。

题目让我们求第n个能够整除abc的数字是什么,也就是说我们要找到一个最小的num,使得f(num, a, b, c) == n

这个num就是第n个能够整除abc的数字。

根据 二分查找的实‍际运用 给出的思路模板,我们得到一个单调函数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函数,结合之前的二分搜索模板,时间复杂度下降到对数级别,即可高效解决这道题目了。

以上就是所有「丑数」相关的题目,用到的知识点有算术基本定理、容斥原理、辗转相除法、链表双指针合并有序链表、二分搜索模板等等。

如果没做过类似的题目可能很难想出来,但只要做过,也就手到擒来了。所以我说这种数学问题属于会者不难,难者不会的类型。

以上是关于微软面试题解析:丑数系列算法的主要内容,如果未能解决你的问题,请参考以下文章

多种解法解决高频面试题--除自身以外数组的乘积

DP-03动态规划算法题目解析

DP-03动态规划算法题目解析

一道求树中每层乘积的和的算法题

剑指Offer对答如流系列 - 丑数

编程之法:面试和算法心得(最大连续乘积子串)