Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit a00feb7

Browse files
committed
feat: add solutions to lc problem: No.0264
No.0264.Ugly Number II
1 parent 986f20a commit a00feb7

File tree

2 files changed

+265
-49
lines changed

2 files changed

+265
-49
lines changed

‎solution/0200-0299/0264.Ugly Number II/README.md‎

Lines changed: 139 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -40,22 +40,46 @@
4040

4141
<!-- 这里可写通用的实现逻辑 -->
4242

43-
动态规划法。
43+
**方法一:优先队列(最小堆)**
4444

45-
定义数组 dp,`dp[i - 1]` 表示第 i 个丑数,那么第 n 个丑数就是 `dp[n - 1]`。最小的丑数是 1,所以 `dp[0] = 1`。
45+
初始时,将第一个丑数 1ドル$ 加入堆。每次取出堆顶元素 $x,ドル由于 2ドルx,ドル 3ドルx,ドル 5ドルx$ 也是丑数,因此将它们加入堆中。为了避免重复元素,可以用哈希表 $vis$ 去重。
4646

47-
定义 3 个指针 p2,p3,p5,表示下一个丑数是当前指针指向的丑数乘以对应的质因数。初始时,三个指针的值都指向 0。
47+
时间复杂度 $O(nlogn),ドル空间复杂度 $O(n)$。
4848

49-
当 `i∈[1,n)`,`dp[i] = min(dp[p2] * 2, dp[p3] * 3, dp[p5] * 5)`,然后分别比较 `dp[i]` 与 `dp[p2] * 2`、`dp[p3] * 3`、`dp[p5] * 5` 是否相等,若是,则对应的指针加 1。
49+
**方法二:动态规划**
5050

51-
最后返回 `dp[n - 1]` 即可。
51+
定义数组 $dp,ドル$dp[i-1]$ 表示第 $i$ 个丑数,那么第 $n$ 个丑数就是 $dp[n - 1]$。最小的丑数是 1ドル,ドル所以 $dp[0]=1$。
52+
53+
定义 3ドル$ 个指针 $p_2,ドル$p_3,ドル$p_5,ドル表示下一个丑数是当前指针指向的丑数乘以对应的质因数。初始时,三个指针的值都指向 0ドル$。
54+
55+
当 $i∈[1,n),ドル$dp[i]=min(dp[p_2] \ * 2, dp[p_3] \ * 3, dp[p_5] \ * 5),ドル然后分别比较 $dp[i]$ 与 $dp[p_2] \ * 2$、$dp[p_3] \ * 3$、$dp[p_5] \ * 5$ 是否相等,若是,则对应的指针加 1ドル$。
56+
57+
最后返回 $dp[n-1]$ 即可。
58+
59+
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。
5260

5361
<!-- tabs:start -->
5462

5563
### **Python3**
5664

5765
<!-- 这里可写当前语言的特殊实现逻辑 -->
5866

67+
```python
68+
class Solution:
69+
def nthUglyNumber(self, n: int) -> int:
70+
h = [1]
71+
vis = {1}
72+
ans = 1
73+
for _ in range(n):
74+
ans = heappop(h)
75+
for v in [2, 3, 5]:
76+
nxt = ans * v
77+
if nxt not in vis:
78+
vis.add(nxt)
79+
heappush(h, nxt)
80+
return ans
81+
```
82+
5983
```python
6084
class Solution:
6185
def nthUglyNumber(self, n: int) -> int:
@@ -77,6 +101,29 @@ class Solution:
77101

78102
<!-- 这里可写当前语言的特殊实现逻辑 -->
79103

104+
```java
105+
class Solution {
106+
public int nthUglyNumber(int n) {
107+
Set<Long> vis = new HashSet<>();
108+
PriorityQueue<Long> q = new PriorityQueue<>();
109+
int[] f = new int[]{2, 3, 5};
110+
q.offer(1L);
111+
vis.add(1L);
112+
long ans = 0;
113+
while (n-- > 0) {
114+
ans = q.poll();
115+
for (int v : f) {
116+
long next = ans * v;
117+
if (vis.add(next)) {
118+
q.offer(next);
119+
}
120+
}
121+
}
122+
return (int) ans;
123+
}
124+
}
125+
```
126+
80127
```java
81128
class Solution {
82129
public int nthUglyNumber(int n) {
@@ -116,29 +163,31 @@ public:
116163
};
117164
```
118165
119-
### **JavaScript**
120-
121-
```js
122-
/**
123-
* @param {number} n
124-
* @return {number}
125-
*/
126-
var nthUglyNumber = function (n) {
127-
let dp = [1];
128-
let p2 = 0,
129-
p3 = 0,
130-
p5 = 0;
131-
for (let i = 1; i < n; ++i) {
132-
const next2 = dp[p2] * 2,
133-
next3 = dp[p3] * 3,
134-
next5 = dp[p5] * 5;
135-
dp[i] = Math.min(next2, Math.min(next3, next5));
136-
if (dp[i] == next2) ++p2;
137-
if (dp[i] == next3) ++p3;
138-
if (dp[i] == next5) ++p5;
139-
dp.push(dp[i]);
166+
```cpp
167+
class Solution {
168+
public:
169+
int nthUglyNumber(int n) {
170+
priority_queue<long, vector<long>, greater<long>> q;
171+
q.push(1l);
172+
unordered_set<long> vis{{1l}};
173+
long ans = 1;
174+
vector<int> f = {2, 3, 5};
175+
while (n--)
176+
{
177+
ans = q.top();
178+
q.pop();
179+
for (int& v : f)
180+
{
181+
long nxt = ans * v;
182+
if (!vis.count(nxt))
183+
{
184+
vis.insert(nxt);
185+
q.push(nxt);
186+
}
187+
}
188+
}
189+
return (int) ans;
140190
}
141-
return dp[n - 1];
142191
};
143192
```
144193

@@ -173,6 +222,69 @@ func min(a, b int) int {
173222
}
174223
```
175224

225+
```go
226+
func nthUglyNumber(n int) int {
227+
h := IntHeap([]int{1})
228+
heap.Init(&h)
229+
ans := 1
230+
vis := map[int]bool{1: true}
231+
for n > 0 {
232+
ans = heap.Pop(&h).(int)
233+
for _, v := range []int{2, 3, 5} {
234+
nxt := ans * v
235+
if !vis[nxt] {
236+
vis[nxt] = true
237+
heap.Push(&h, nxt)
238+
}
239+
}
240+
n--
241+
}
242+
return ans
243+
}
244+
245+
type IntHeap []int
246+
247+
func (h IntHeap) Len() int { return len(h) }
248+
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
249+
func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
250+
func (h *IntHeap) Push(x interface{}) {
251+
*h = append(*h, x.(int))
252+
}
253+
func (h *IntHeap) Pop() interface{} {
254+
old := *h
255+
n := len(old)
256+
x := old[n-1]
257+
*h = old[0 : n-1]
258+
return x
259+
}
260+
```
261+
262+
### **JavaScript**
263+
264+
```js
265+
/**
266+
* @param {number} n
267+
* @return {number}
268+
*/
269+
var nthUglyNumber = function (n) {
270+
let dp = [1];
271+
let p2 = 0,
272+
p3 = 0,
273+
p5 = 0;
274+
for (let i = 1; i < n; ++i) {
275+
const next2 = dp[p2] * 2,
276+
next3 = dp[p3] * 3,
277+
next5 = dp[p5] * 5;
278+
dp[i] = Math.min(next2, Math.min(next3, next5));
279+
if (dp[i] == next2) ++p2;
280+
if (dp[i] == next3) ++p3;
281+
if (dp[i] == next5) ++p5;
282+
dp.push(dp[i]);
283+
}
284+
return dp[n - 1];
285+
};
286+
```
287+
176288
### **C#**
177289

178290
```cs

‎solution/0200-0299/0264.Ugly Number II/README_EN.md‎

Lines changed: 126 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,22 @@
3838

3939
### **Python3**
4040

41+
```python
42+
class Solution:
43+
def nthUglyNumber(self, n: int) -> int:
44+
h = [1]
45+
vis = {1}
46+
ans = 1
47+
for _ in range(n):
48+
ans = heappop(h)
49+
for v in [2, 3, 5]:
50+
nxt = ans * v
51+
if nxt not in vis:
52+
vis.add(nxt)
53+
heappush(h, nxt)
54+
return ans
55+
```
56+
4157
```python
4258
class Solution:
4359
def nthUglyNumber(self, n: int) -> int:
@@ -75,6 +91,29 @@ class Solution {
7591
}
7692
```
7793

94+
```java
95+
class Solution {
96+
public int nthUglyNumber(int n) {
97+
Set<Long> vis = new HashSet<>();
98+
PriorityQueue<Long> q = new PriorityQueue<>();
99+
int[] f = new int[]{2, 3, 5};
100+
q.offer(1L);
101+
vis.add(1L);
102+
long ans = 0;
103+
while (n-- > 0) {
104+
ans = q.poll();
105+
for (int v : f) {
106+
long next = ans * v;
107+
if (vis.add(next)) {
108+
q.offer(next);
109+
}
110+
}
111+
}
112+
return (int) ans;
113+
}
114+
}
115+
```
116+
78117
### **C++**
79118

80119
```cpp
@@ -96,29 +135,31 @@ public:
96135
};
97136
```
98137
99-
### **JavaScript**
100-
101-
```js
102-
/**
103-
* @param {number} n
104-
* @return {number}
105-
*/
106-
var nthUglyNumber = function (n) {
107-
let dp = [1];
108-
let p2 = 0,
109-
p3 = 0,
110-
p5 = 0;
111-
for (let i = 1; i < n; ++i) {
112-
const next2 = dp[p2] * 2,
113-
next3 = dp[p3] * 3,
114-
next5 = dp[p5] * 5;
115-
dp[i] = Math.min(next2, Math.min(next3, next5));
116-
if (dp[i] == next2) ++p2;
117-
if (dp[i] == next3) ++p3;
118-
if (dp[i] == next5) ++p5;
119-
dp.push(dp[i]);
138+
```cpp
139+
class Solution {
140+
public:
141+
int nthUglyNumber(int n) {
142+
priority_queue<long, vector<long>, greater<long>> q;
143+
q.push(1l);
144+
unordered_set<long> vis{{1l}};
145+
long ans = 1;
146+
vector<int> f = {2, 3, 5};
147+
while (n--)
148+
{
149+
ans = q.top();
150+
q.pop();
151+
for (int& v : f)
152+
{
153+
long nxt = ans * v;
154+
if (!vis.count(nxt))
155+
{
156+
vis.insert(nxt);
157+
q.push(nxt);
158+
}
159+
}
160+
}
161+
return (int) ans;
120162
}
121-
return dp[n - 1];
122163
};
123164
```
124165

@@ -153,6 +194,69 @@ func min(a, b int) int {
153194
}
154195
```
155196

197+
```go
198+
func nthUglyNumber(n int) int {
199+
h := IntHeap([]int{1})
200+
heap.Init(&h)
201+
ans := 1
202+
vis := map[int]bool{1: true}
203+
for n > 0 {
204+
ans = heap.Pop(&h).(int)
205+
for _, v := range []int{2, 3, 5} {
206+
nxt := ans * v
207+
if !vis[nxt] {
208+
vis[nxt] = true
209+
heap.Push(&h, nxt)
210+
}
211+
}
212+
n--
213+
}
214+
return ans
215+
}
216+
217+
type IntHeap []int
218+
219+
func (h IntHeap) Len() int { return len(h) }
220+
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
221+
func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
222+
func (h *IntHeap) Push(x interface{}) {
223+
*h = append(*h, x.(int))
224+
}
225+
func (h *IntHeap) Pop() interface{} {
226+
old := *h
227+
n := len(old)
228+
x := old[n-1]
229+
*h = old[0 : n-1]
230+
return x
231+
}
232+
```
233+
234+
### **JavaScript**
235+
236+
```js
237+
/**
238+
* @param {number} n
239+
* @return {number}
240+
*/
241+
var nthUglyNumber = function (n) {
242+
let dp = [1];
243+
let p2 = 0,
244+
p3 = 0,
245+
p5 = 0;
246+
for (let i = 1; i < n; ++i) {
247+
const next2 = dp[p2] * 2,
248+
next3 = dp[p3] * 3,
249+
next5 = dp[p5] * 5;
250+
dp[i] = Math.min(next2, Math.min(next3, next5));
251+
if (dp[i] == next2) ++p2;
252+
if (dp[i] == next3) ++p3;
253+
if (dp[i] == next5) ++p5;
254+
dp.push(dp[i]);
255+
}
256+
return dp[n - 1];
257+
};
258+
```
259+
156260
### **C#**
157261

158262
```cs

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /