LeetCode 264 丑数2

1.题目描述：

给你一个整数 n ，请你找出并返回第 n 个丑数。丑数就是只包含质因数 2、3 或 5 的正整数。

示例 1：

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

2.题解：

方法一：优先队列

要得到从小到大第N个丑数，可以用最小堆来实现。

初始时，堆为空，同时创建一个哈希表来判重。
每次取出堆顶元素 x，则 x 是堆中最小的丑数，由于 2x, 3x, 5x 也是丑数，因此将 2x, 3x, 5x 加入堆。

时间复杂度：O（n logn ）,得到第n个丑数，要n次循环，并且每次都得从堆中取出1个元素；
空间复杂度：O（n），空间复杂度取决于哈希表和队列的空间总和，最多不会超过3n。

C++

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int>factor = {2, 3, 5} ;
        unordered_set<long>seen ; //快速判重
        priority_queue<long, vector<long>,greater<long>> heap ; //大根堆
        seen.insert(1) ;
        heap.push(1) ;
        int ugly = 0  ;
        for (int i = 0; i < n; i++) {
            long curr = heap.top() ;
            heap.pop() ;
            ugly = (int)curr ;
            for (auto x : factor ) {
                long next = x * curr ;
                if (!seen.count(next)) {
                seen.insert(next) ;
                heap.push(next) ;
                }
            }
        }
        return ugly ;
    }
};

Golang：

var factors = []int{2,3,5}
type hp struct {
    sort.IntSlice
}
func (h *hp) Push(v interface{} ) {h.IntSlice = append(h.IntSlice, v.(int))}
func (h *hp) Pop() interface{} { a:= h.IntSlice; v := a[len(a)-1]; h.IntSlice = a[:len(a)-1]; return v }
func nthUglyNumber(n int) int {
    h := &hp{sort.IntSlice{1}} 
    seen := map[int]struct{} {1: {}}
    for i := 1; ; i++ {
        x := heap.Pop(h).(int)
        if i == n {
            return x
        }
        for _, f := range factors {
            next := x * f
            if _, has := seen[next]; !has {
                heap.Push(h, next)
                seen[next] = struct{}{}
            }
        }
    }
}

方法二：动态规划

丑数的因子一定是丑数，它一定是通过乘以2，3或5 得到的，因此可以使用动态规划的思想，利用前面已得到的丑数序列，利用转态转移方程来得到后面的丑数序列。
利用三个指针， 分别记录乘以2,3和5得出目前最大的丑陋数，而新的丑数是其中最小的，那么就更新相应的指针，获得新的目前最大的丑数，以此类推，得到最终需要的结果。
时间复杂度： O（n）需要计算数组中n个元素；
空间复杂度： O（n）。

C++：

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> ans(1,1) ;
        for ( int i = 0 ,j= 0 ,k = 0 ; ans.size() < n ;) {
            int t = min(ans[i]*2 , min(ans[j]*3, ans[k]*5)) ;
            ans.push_back(t) ;
            if (ans[i]*2 == t) i++ ;
            if (ans[j]*3 == t) j++ ;
            if (ans[k]*5 == t) k++ ;
        } 
        return ans.back() ;
    }
};

Golang：

func nthUglyNumber(n int) int {
    ans := []int{1}
    for i, j, k := 0, 0, 0; len(ans) < n ; {
        t := min (ans[i]*2, min(ans[j]*3, ans[k]*5)) 
        ans = append(ans, t) 
        if ans[i]*2 == t {
            i++
        }
        if ans[j]*3==t {
            j++
        }
        if ans[k]*5 ==t {
            k++
        }
    }
    return ans[len(ans)-1]
}
func min (a, b int) int {
    if ( a < b) {
        return a
    }
    return b
}