Leetcode264

Leetcode264

首先我们要先理解题目的意思，返回丑数，丑数就是包含质因数2、3和5的正整数，1被视为丑数，丑数也可以理解为2,3,5各自的倍数，题目要求我们返回丑数

目的：计算得到丑数，排列丑数，再返回指定位置丑数。

解法一 ：优先队列（最小堆）

解题思路

一开始，用暴力的方法去破解，很容易想到，每个数去判断是否为丑数，然后count+1，最后返回传入的第n个位置的丑数，但这种枚举的方法，效率低，且超时，所以不算入解法里。

1.起始先将最小丑数 1 放入队列
2.每次从队列取出最小值 x，然后将 x 所对应的丑数 2x，3x 和 5x 进行入队。
3.对步骤 2 循环多次，第 n次出队的值即是答案。

那这里我们可以用优先队列的方法

public int nthUglyNumber(int n) {
    Queue<Long> que = new PriorityQueue<Long>();
    //PriorityQueue  队列元素根据自然排序
    int count = 0;
    long result = 1;
    //这里要用long不然会有溢出的情况
    que.add(result);
    while (count < n) {
        result = que.poll();
        // 删除重复的
        while (!que.isEmpty() && result == que.peek()) {
            que.poll();
        }
        count++;
        que.offer(result * 2);
        que.offer(result * 3);
        que.offer(result * 5);
    }
    return (int) result;
}

当然，因为这里用的是优先队列，所以要考虑重复的情况，如果用集合的话就能，避免这一情况。

public int nthUglyNumber(int n) {
    TreeSet<Long> set = new TreeSet<Long>();
    int count = 0;
    long result = 1;
    set.add(result);
    while (count < n) {
        result = set.pollFirst();
        count++;
        set.add(result * 2);
        set.add(result * 3);
        set.add(result * 5);
    }
    return (int) result;
}

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

这里是官方给出的解法，用哈希集合去重，然后用优先队列形成的最小堆进行排序。

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

解法二：动态规划（三指针）

用dp代表有序的丑数队列，那么新的丑数总是通过该队列中现有的元素x2，x3或者x5得到，我们分别用指针p2，p3，p5来代表这三种操作，那么dp[p2]就是将要进行这种操作的数。

dp[i] = Math.min(dp[p2]*2,dp[p3]*3,dp[p5]*5)

  public int nthUglyNumber(int n) {
        int p2= 1,p3=1,p5=1;
        int[] dp = new int[n+1];
        dp[1] =1;
        for(int i=2;i<n+1;i++){
            int num1 = dp[p2]*2;
            int num2 = dp[p3]*3;
            int num3 = dp[p5]*5;
            dp[i] = Math.min(num1,Math.min(num2,num3));
            if(dp[i]==num1){
                p2++;
            }
            if(dp[i]==num2){
                p3++;
            }
            if(dp[i]==num3){
                p5++;
            }
        }
        return dp[n];
  }

时间复杂度o(n)，空间复杂度o(n)

总结

本题是动态规划的经典例题，难度不高，但加以思考多种解法，体会也比较深刻