๋ฌธ์
์ฐํ์ด๋ ์ด๋ฆฐ ์์ , ์ง๊ตฌ ์ธ์ ๋ค๋ฅธ ํ์ฑ์์๋ ์ธ๋ฅ๋ค์ด ์ด์๊ฐ ์ ์๋ ๋ฏธ๋๊ฐ ์ค๋ฆฌ๋ผ ๋ฏฟ์๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ๊ฐ ์ง๊ตฌ๋ผ๋ ์ธ์์ ๋ฐ์ ๋ด๋ ค ๋์ ์ง 23๋
์ด ์ง๋ ์ง๊ธ, ์ธ๊ณ ์ต์ฐ์ ASNA ์ฐ์ฃผ ๋นํ์ฌ๊ฐ ๋์ด ์๋ก์ด ์ธ๊ณ์ ๋ฐ์ ๋ด๋ ค ๋๋ ์๊ด์ ์๊ฐ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ค. ๊ทธ๊ฐ ํ์นํ๊ฒ ๋ ์ฐ์ฃผ์ ์ Alpha Centauri๋ผ๋ ์๋ก์ด ์ธ๋ฅ์ ๋ณด๊ธ์๋ฆฌ๋ฅผ ๊ฐ์ฒํ๊ธฐ ์ํ ๋๊ท๋ชจ ์ํ ์ ์ง ์์คํ
์ ํ์ฌํ๊ณ ์๊ธฐ ๋๋ฌธ์, ๊ทธ ํฌ๊ธฐ์ ์ง๋์ด ์์ฒญ๋ ์ด์ ๋ก ์ต์ ๊ธฐ์ ๋ ฅ์ ์ด ๋์ํ์ฌ ๊ฐ๋ฐํ ๊ณต๊ฐ์ด๋ ์ฅ์น๋ฅผ ํ์ฌํ์๋ค. ํ์ง๋ง ์ด ๊ณต๊ฐ์ด๋ ์ฅ์น๋ ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธ๊ฒฉํ๊ฒ ๋๋ฆด ๊ฒฝ์ฐ ๊ธฐ๊ณ์ ์ฌ๊ฐํ ๊ฒฐํจ์ด ๋ฐ์ํ๋ ๋จ์ ์ด ์์ด์, ์ด์ ์๋์๊ธฐ์ k๊ด๋
์ ์ด๋ํ์์ ๋๋ k-1 , k ํน์ k+1 ๊ด๋
๋ง์ ๋ค์ ์ด๋ํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, ์ด ์ฅ์น๋ฅผ ์ฒ์ ์๋์ํฌ ๊ฒฝ์ฐ -1 , 0 , 1 ๊ด๋
์ ์ด๋ก ์ ์ด๋ํ ์ ์์ผ๋ ์ฌ์ค์ ์์ ํน์ 0 ๊ฑฐ๋ฆฌ๋งํผ์ ์ด๋์ ์๋ฏธ๊ฐ ์์ผ๋ฏ๋ก 1 ๊ด๋
์ ์ด๋ํ ์ ์์ผ๋ฉฐ, ๊ทธ ๋ค์์๋ 0 , 1 , 2 ๊ด๋
์ ์ด๋ํ ์ ์๋ ๊ฒ์ด๋ค. ( ์ฌ๊ธฐ์ ๋ค์ 2๊ด๋
์ ์ด๋ํ๋ค๋ฉด ๋ค์ ์๊ธฐ์ 1, 2, 3 ๊ด๋
์ ์ด๋ํ ์ ์๋ค. ) ๊น์ฐํ์ ๊ณต๊ฐ์ด๋ ์ฅ์น ์๋์์ ์๋์ง ์๋ชจ๊ฐ ํฌ๋ค๋ ์ ์ ์ ์๊ณ ์๊ธฐ ๋๋ฌธ์ x์ง์ ์์ y์ง์ ์ ํฅํด ์ต์ํ์ ์๋ ํ์๋ก ์ด๋ํ๋ ค ํ๋ค. ํ์ง๋ง y์ง์ ์ ๋์ฐฉํด์๋ ๊ณต๊ฐ ์ด๋์ฅ์น์ ์์ ์ฑ์ ์ํ์ฌ y์ง์ ์ ๋์ฐฉํ๊ธฐ ๋ฐ๋ก ์ง์ ์ ์ด๋๊ฑฐ๋ฆฌ๋ ๋ฐ๋์ 1๊ด๋
์ผ๋ก ํ๋ ค ํ๋ค. ๊น์ฐํ์ ์ํด x์ง์ ๋ถํฐ ์ ํํ y์ง์ ์ผ๋ก ์ด๋ํ๋๋ฐ ํ์ํ ๊ณต๊ฐ ์ด๋ ์ฅ์น ์๋ ํ์์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์
๋ ฅ
์
๋ ฅ์ ์ฒซ ์ค์๋ ํ
์คํธ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ๊ฐ์ ํ
์คํธ ์ผ์ด์ค์ ๋ํด ํ์ฌ ์์น x ์ ๋ชฉํ ์์น y ๊ฐ ์ ์๋ก ์ฃผ์ด์ง๋ฉฐ, x๋ ํญ์ y๋ณด๋ค ์์ ๊ฐ์ ๊ฐ๋๋ค. (0 โค x < y < 2^31)
์ถ๋ ฅ
๊ฐย ํ
์คํธย ์ผ์ด์ค์ย ๋ํดย x์ง์ ์ผ๋ก๋ถํฐย y์ง์ ๊น์งย ์ ํํย ๋๋ฌํ๋๋ฐย ํ์ํย ์ต์ํ์ย ๊ณต๊ฐ์ด๋ย ์ฅ์นย ์๋ย ํ์๋ฅผย ์ถ๋ ฅํ๋ค.
์์
โ
์
๋ ฅ 1
โ
์ถ๋ ฅ 1
์์ฑ ์ฝ๋
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
| public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
for (int i = 0; i < t; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken());
int y = Integer.parseInt(st.nextToken());
int count = 0;
if (x == y) {
System.out.println(count);
continue;
}
bfs(x, y);
}
}
private static void bfs(int x, int y) {
int distance = y - x;
boolean[] visited = new boolean[distance + 1];
Deque<int[]> queue = new ArrayDeque<>();
queue.addLast(new int[]{x, 0, 0});
visited[0] = true;
while (!queue.isEmpty()) {
int[] element = queue.pollFirst();
int prev = element[0];
int count = element[1];
int move = element[2];
if (prev == y - 1) {
System.out.println(count + 1);
return;
}
for (int d = move - 1; d <= move + 1; d++) {
if (d <= 0) continue;
int current = prev + d;
if (current < y && !visited[current - x]) {
queue.addLast(new int[]{current, count + 1, d});
visited[current - x] = true;
}
}
}
}
}
|
BFS
๋ก ๋ฌธ์ ๋ฅผ ํ์์ผ๋, ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.- ํ๊ณ ๋๋ ๋ฌธ์ ์์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ ์ธก๋ฉด์์
BFS
์ ์ ํฉํ์ง ์๋ค๋ ๊ฑธ ์๊ฒ ๋์๋ค.
๊ฐ์ ์ฝ๋
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
| /*
ย ย ย ย 1
ย ย ย ย 11
ย ย ย ย 111
ย ย ย ย 121
ย ย ย ย 1211
ย ย ย ย 1121
ย ย ย ย 1221
ย ย ย ย 12211
ย ย ย ย 11221
ย ย ย ย 12221
ย ย ย ย ...
*/
public class Main {
public static void main(String[] args) throws IOException {
// 1. ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
// 2. ํ
์คํธ ์ผ์ด์ค ์ํ
for (int i = 0; i < t; i++) {
// ์ง์ญ ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ
StringTokenizer st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken());
int y = Integer.parseInt(st.nextToken());
int distance = y - x;
int move = 1, count = 0, current = 0;
// ์ด๋ ์ฒ๋ฆฌ
while (current < distance) {
if (distance - current <= move) {
count++;
break;
} else if (distance - current < move * 2) {
count += 2;
break;
} else {
count += 2;
current += move++ * 2;
}
}
// ์ถ๋ ฅ
System.out.println(count);
}
}
}
|
- ๊ท์น์ ์ฐพ์์
Brute-force
๋ฐฉ์์ผ๋ก ํ์๋ค.
ํ๊ณ
- ์๊ฐ ๋ ๋ ๋ ๋์ ๋ฐฉ๋ฒ์ด ์๋์ง ์๊ฐํด๋ณด์์ผ๊ฒ ๋ค.