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)
总结
本题是动态规划的经典例题,难度不高,但加以思考多种解法,体会也比较深刻