Leetcode_丑数问题

1. 263. 丑数

给你一个整数 n ,请你判断 n 是否为 丑数 。如果是,返回 true ;否则,返回 false 。

丑数 就是只包含质因数 2、3 或 5 的正整数。

示例 1:

输入:n = 6
输出:true
解释:6 = 2 × 3

示例 3:

输入:n = 14
输出:false
解释:14 不是丑数,因为它包含了另外一个质因数 7 。

题解

这个题其实很简单。因为丑数的概念就必须是只有2、3、5这三个质因子的数。

那它需要满足什么条件那

  1. 如果这个数是2的倍数则就除2
  2. 如果是3的倍数则就除3
  3. 如果是5的倍数就除5

如果这个是丑数的话,那这样剩下的数一定是1。

证明

如果这个数不是1,那么也不能是2,3,5的倍数。那么他就必须是7, 11 这种的质因子。

这与它是丑数相悖。所以一定满足上面说的条件,那代码就呼之欲出了

代码

class Solution {
public:
    bool isUgly(int n) {
        if (n < 1)return false;
        while(n % 2 == 0) n /= 2; 
        while(n % 3 == 0) n /= 3; 
        while(n % 5 == 0) n /= 5; 
        return n == 1;
    }
};

2. 264. 丑数 II

给你一个整数 n ,请你找出并返回第 n丑数

丑数 就是只包含质因数 23 和/或 5 的正整数。

示例 1:

输入:n = 10
输出:12
解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。

示例 2:

输入:n = 1
输出:1
解释:1 通常被视为丑数。

题解

这个题和上面的区别就是要我们找出第n个丑数。

实际上我们可以先列表找一个感觉1、2、3、4、5、6、8、9、10、12 .....

我们把这个序列称为S那我们要返回的就是S[n]
我们用S2表示只包含质因子2的数。S3表示只包含质因子3的数。S5表示只包含质因子为5的数

S2 : 2, 4, 6 , 8 , ....

S3 : 3, 6, 9 , 12, 15 ...

S5 : 5, 10, 15, ....

可以发现S数组的数就是从S2,S3,S5并操作得到的(在并上一个1)

另外一个特性就是 S2 = 2 * S, S3 = 3 * S , S5 = 5 * S

这样就可以用三个指针指向1这个数。

然后对指针往下移动。依次取三个指针的最小值。最后就可以得到S序列,那代码也就好写了

代码

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int>q(1,1); // 表示只有1这个数,是第一个丑数
        for (int i = 0, j = 0, k = 0; q.size() < n; ) {
            int t = min(q[i] * 2, min(q[j] * 3, q[k] * 5));
            if (t == q[i] * 2) i++;
            if (t == q[j] * 3) j++;
            if (t == q[k] * 5) k++;
            q.push_back(t);
        }
        return q[n - 1];
    }
};

3. 313. 超级丑数

超级丑数 是一个正整数,并满足其所有质因数都出现在质数数组 primes 中。

给你一个整数 n 和一个整数数组 primes ,返回第 n超级丑数

题目数据保证第 n超级丑数32-bit 带符号整数范围内。

示例 1:

输入:n = 12, primes = [2,7,13,19]
输出:32
解释:给定长度为 4 的质数数组 primes = [2,7,13,19],前 12 个超级丑数序列为:[1,2,4,7,8,13,14,16,19,26,28,32] 。

示例 2:

输入:n = 1, primes = [2,3,5]
输出:1
解释:1 不含质因数,因此它的所有质因数都在质数数组 primes = [2,3,5] 中。

题解

这个题和上面的题,非常类似哦。

只不过是上面的要求是只能有2,3,5而这个题目给了一个要求是只能包含特定序列的质数

因此这里用了一个小根堆来存储相关的最小值。这样每次logk就可以了

这里的指针移动就是向堆内加入一个新的元素

  1. 这里利用这样的一个堆存储{value, position} position为这个值是由数组中哪个值更新的
  2. 然后算除当前值是由之前的值如何更新的。因为一定是会??一个集合内的素数
  3. 随后将这个集合指针往下移动那就是入堆一个{p * q[idx + 1], idx + 1}

代码

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
       typedef pair<int,int> PII;
       priority_queue<PII, vector<PII>, greater<PII>> heap;
       for (auto e : primes) {
           heap.push({e, 0});
       }
       vector<int>q(n);
       q[0] = 1;
       for (int i = 1; i < n; ) {
           auto t = heap.top();
           heap.pop();
           if (t.first != q[i - 1])q[i++] = t.first;
           int idx = t.second;
           int p  = t.first / q[idx];
           heap.push({p * q[idx + 1], idx+1});
       }
       return q[n - 1];
    } 
};

Leetcode_丑数问题

上一篇:prometheus+exporter小测试:


下一篇:测试开发CICD——Docker—— 镜像简单使用