์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ | ์ ๋ต ๋น์จ |
2 ์ด | 128 MB | 57.281% |
๋ฌธ์
N์ฅ์ ์นด๋๊ฐ ์๋ค. ๊ฐ๊ฐ์ ์นด๋๋ ์ฐจ๋ก๋ก 1๋ถํฐ N๊น์ง์ ๋ฒํธ๊ฐ ๋ถ์ด ์์ผ๋ฉฐ, 1๋ฒ ์นด๋๊ฐ ์ ์ผ ์์, N๋ฒ ์นด๋๊ฐ ์ ์ผ ์๋์ธ ์ํ๋ก ์์๋๋ก ์นด๋๊ฐ ๋์ฌ ์๋ค.
์ด์ ๋ค์๊ณผ ๊ฐ์ ๋์์ ์นด๋๊ฐ ํ ์ฅ ๋จ์ ๋๊น์ง ๋ฐ๋ณตํ๊ฒ ๋๋ค. ์ฐ์ , ์ ์ผ ์์ ์๋ ์นด๋๋ฅผ ๋ฐ๋ฅ์ ๋ฒ๋ฆฐ๋ค. ๊ทธ ๋ค์, ์ ์ผ ์์ ์๋ ์นด๋๋ฅผ ์ ์ผ ์๋์ ์๋ ์นด๋ ๋ฐ์ผ๋ก ์ฎ๊ธด๋ค.
์๋ฅผ ๋ค์ด N=4์ธ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด ๋ณด์. ์นด๋๋ ์ ์ผ ์์์๋ถํฐ 1234 ์ ์์๋ก ๋์ฌ์๋ค. 1์ ๋ฒ๋ฆฌ๋ฉด 234๊ฐ ๋จ๋๋ค. ์ฌ๊ธฐ์ 2๋ฅผ ์ ์ผ ์๋๋ก ์ฎ๊ธฐ๋ฉด 342๊ฐ ๋๋ค. 3์ ๋ฒ๋ฆฌ๋ฉด 42๊ฐ ๋๊ณ , 4๋ฅผ ๋ฐ์ผ๋ก ์ฎ๊ธฐ๋ฉด 24๊ฐ ๋๋ค. ๋ง์ง๋ง์ผ๋ก 2๋ฅผ ๋ฒ๋ฆฌ๊ณ ๋๋ฉด, ๋จ๋ ์นด๋๋ 4๊ฐ ๋๋ค.
N์ด ์ฃผ์ด์ก์ ๋, ์ ์ผ ๋ง์ง๋ง์ ๋จ๊ฒ ๋๋ ์นด๋๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ ์ N(1≤N≤500,000)์ด ์ฃผ์ด์ง๋ค.
์ฒซ์งธ ์ค์ ๋จ๊ฒ ๋๋ ์นด๋์ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
ํด๊ฒฐ
Node ํด๋์ค๋ฅผ ๊ตฌ์ฑํด์ ๋ฌธ์ ์์ ์ฃผ์ด์ง ๊ทธ๋๋ก ๊ตฌํํ๋ค.
- 1๋ถํฐ N๊น์ง์ ์นด๋๋ฅผ ๊ตฌ์ฑํ๋ค → 28~35๋ฒ ์ค
- nodeNum ์ '๋จ์์๋ ์นด๋์ ์'์ด๋ฉฐ ๋งจ ๋ค๋ก๋ณด๋ด๋ ์์ ์ ํ ์ NULL์ ๊ฐ๋ฆฌํค๋ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํจ์ด๋ค.
- while ๋ฌธ์ ํ์ฉํ์ฌ ์นด๋๊ฐ ํ๋ ๋จ์ ์์ ๋ ๊น์ง ๋๋ค.
- ๋งจ ์์ ์๋ ์นด๋๋ฅผ ์ญ์ ํ๊ณ → 39~42๋ฒ ์ค
- ๊ทธ ๋ค์ ๋งจ ์์ ์๋ ์นด๋๋ฅผ ๋งจ ๋ค๋ก ๋ณด๋ธ๋ค. → 44~52๋ฒ ์ค
- ์ด๋ ๊ฒ while๋ฌธ์ ๋น ์ ธ๋์จ ๋ค ๋งจ ์์ ์๋ ์นด๋๋ฅผ ์ถ๋ ฅํ๋ฉด ์ ๋ต์ด๋ค.
์ฝ๋
๋ฉ๋ชจ๋ฆฌ | ์๊ฐ |
17560 KB | 40 ms |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
#include <iostream>
class Node {
public:
int data;
Node* prev;
Node* next;
Node() {
prev = 0;
next = 0;
}
};
Node head;
Node tail;
int nodeNum;
int main() {
int n;
scanf("%d", &n);
// ๋ฌธ์์ด์ ์ ์ฅํ ๋ ๋ฒ์๋ ์์คํค์ฝ๋.
//ํฌ์ธํฐ๊ฐ ์ด ๊ฐ์ ๋๋ฌํ์ ๋ ๋์์ ์๊ฒํ๊ธฐ ์ํด์
head.data = -1;
tail.data = -1;
head.next = &tail;
tail.prev = &head;
for (int i = 1; i <= n; i++) {
Node* nNode = new Node;
nNode->data = i;
nNode->prev = tail.prev;
nNode->next = &tail;
tail.prev->next = nNode;
nNode->next->prev = nNode;
}
nodeNum = n;
while (nodeNum > 1) {
// ๋งจ ์ ์ญ์
Node* remove = head.next;
head.next = remove->next;
remove->next->prev = &head;
free(remove); nodeNum--;
// ๋งจ ์ ๋งจ ์์๊ฑฐ ๋งจ ๋ค๋ก ๋ณด๋ด๊ธฐ
Node* front = head.next;
if (nodeNum >= 2) {
head.next = front->next;
front->next->prev = &head;
}
tail.prev->next = front;
front->prev = tail.prev;
front->next = &tail;
tail.prev = front;
}
printf("%d", head.next->data);
return 0;
}
|
cs |
'๐ฅ PS(Problem Solving) ๐ฅ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] #12789 ๋ํค๋ํค ๊ฐ์๋๋ฆฌ๋ฏธ (0) | 2020.06.02 |
---|---|
[BOJ] #1406 ์๋ํฐ (0) | 2020.06.02 |
[BOJ] #14830 ๊ฒฝ์ฌ๋ก (0) | 2020.05.21 |
[BOJ] #5397 ํค๋ก๊ฑฐ (0) | 2020.05.21 |
[BOJ] #1912 ์ฐ์ํฉ (0) | 2020.05.11 |
๋๊ธ