算法笔记-lc-面试题 17.09. 第 k 个数（中等）

题目

题干

有些数的素因子只有 3，5，7，请设计一个算法找出第 k 个数。注意，不是必须有这些素因子，而是必须不包含其他的素因子。例如，前几个数按顺序应该是 1，3，5，7，9，15，21。

示例

示例 1:

输入: k = 5

输出: 9

题解

方法一：最小堆

要得到从小到大的第 k 个数，可以使用最小堆实现。

初始时堆为空。首先将最小的数 1 加入堆。

每次取出堆顶元素 x，则 x 是堆中最小的数，由于 3x, 5x, 7x也是符合要求的数，因此将 3x, 5x, 7x加入堆。

上述做法会导致堆中出现重复元素的情况。为了避免重复元素，可以使用哈希集合去重，避免相同元素多次加入堆。

在排除重复元素的情况下，第 k 次从最小堆中取出的元素即为第 k 个数。

class Solution {
    public int getKthMagicNumber(int k) {
        int[] factors = {3, 5, 7};
        Set<Long> seen = new HashSet<Long>();
        PriorityQueue<Long> heap = new PriorityQueue<Long>();
        seen.add(1L);
        heap.offer(1L);
        int magic = 0;
        for (int i = 0; i < k; i++) {
            long curr = heap.poll();
            magic = (int) curr;
            for (int factor : factors) {
                long next = curr * factor;
                if (seen.add(next)) {
                    heap.offer(next);
                }
            }
        }
        return magic;
    }
}

复杂度分析

时间复杂度：O(klogk)。得到第 k 个数需要进行 k 次循环，每次循环都要从最小堆中取出 1 个元素以及向最小堆中加入最多 3 个元素，因此每次循环的时间复杂度是 O(log(3k)+3log(3k))=O(logk)，总时间复杂度是O(klogk)。

空间复杂度：O(k)。空间复杂度主要取决于最小堆和哈希集合的大小，最小堆和哈希集合的大小都不会超过 3k。

方法二：动态规划

方法一使用最小堆，会预先存储较多的数，维护最小堆的过程也导致时间复杂度较高。可以使用动态规划的方法进行优化。

定义数组 dp，其中dp[i] 表示第 i 个数，第 k 个数即为 dp[k]。

由于最小的数是 1，因此dp[1]=1。

如何得到其余的数呢？定义三个指针p3 ,p5 ,p7，表示下一个数是当前指针指向的数乘以对应的质因数。初始时，三个指针的值都是 1。

当 2≤i≤k 时，令dp[i]=min(dp[p3]×3,dp[p5]×5,dp[p7]×7)，然后分别比较 dp[i] 和dp[p3
]×3,dp[p5]×5,dp[p7]×7 是否相等，如果相等则将对应的指针加 1。

正确性证明

对于 i>1，在计算 dp[i] 时，指针px(x∈{3,5,7}) 的含义是使得 dp[j]×x>dp[i−1] 的最小的下标 j，即当j≥px时dp[j]×x>dp[i−1]，当 j<px时dp[j]×x≤dp[i−1]。

因此，对于 i>1，在计算 dp[i] 时，dp[p3]×3,dp[p5]×5,dp[p7]×7 都大于 dp[i−1]，dp[p3
−1]×3,dp[p5−1]×5,dp[p7−1]×7 都小于或等于 dp[i−1]。令 dp[i]=min(dp[p3]×3,dp[p5]×5,dp[p7]×7)，则dp[i]>dp[i−1] 且 dp[i] 是大于dp[i−1] 的最小的数。

在计算 dp[i] 之后，会更新三个指针 p3 ,p5 ,p 7，更新之后的指针将用于计算 dp[i+1]，同样满足 dp[i+1]>dp[i] 且dp[i+1] 是大于dp[i] 的最小的数。

class Solution {
    public int getKthMagicNumber(int k) {
        int[] dp = new int[k + 1];
        dp[1] = 1;
        int p3 = 1, p5 = 1, p7 = 1;
        for (int i = 2; i <= k; i++) {
            int num3 = dp[p3] * 3, num5 = dp[p5] * 5, num7 = dp[p7] * 7;
            dp[i] = Math.min(Math.min(num3, num5), num7);
            if (dp[i] == num3) {
                p3++;
            }
            if (dp[i] == num5) {
                p5++;
            }
            if (dp[i] == num7) {
                p7++;
            }
        }
        return dp[k];
    }
}

复杂度分析

时间复杂度：O(k)。需要计算数组dp 中的 k个元素，每个元素的计算都可以在O(1) 的时间内完成。

空间复杂度：O(k)。空间复杂度主要取决于数组 \textit{dp}dp 的大小。

方法三：欧拉筛

可以参考网上欧拉筛的算法实现和讲解。