Tags
- ์ ์๋ก
- ์๋ฎฌ๋ ์ด์
- DP
- Python
- SpringBoot
- LV2
- Dynamic Programming
- ๊ทธ๋ํ ํ์
- ๋ฌธ์์ด
- ๊ตฌํ
- BOJ
- stack
- dfs
- ๋ฐฑํธ๋ํน
- CodingTest
- greedy
- PGM
- Study
- ์ ๋ ฌ
- BFS
- ๊ต์ฌ
- ๋๋น ์ฐ์ ํ์
- Java
- ์๋ฃ๊ตฌ์กฐ
- ๊ทธ๋ํ ์ด๋ก
- ์ํ
- Brute Force Algorithm
- sort
- queue
- ๊น์ด ์ฐ์ ํ์
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_1914 : ํ๋ ธ์ด ํ ๋ณธ๋ฌธ
1914๋ฒ: ํ๋ ธ์ด ํ
์ธ ๊ฐ์ ์ฅ๋๊ฐ ์๊ณ ์ฒซ ๋ฒ์งธ ์ฅ๋์๋ ๋ฐ๊ฒฝ์ด ์๋ก ๋ค๋ฅธ n๊ฐ์ ์ํ์ด ์์ฌ ์๋ค. ๊ฐ ์ํ์ ๋ฐ๊ฒฝ์ด ํฐ ์์๋๋ก ์์ฌ์๋ค. ์ด์ ์๋์น๋ค์ด ๋ค์ ๊ท์น์ ๋ฐ๋ผ ์ฒซ ๋ฒ์งธ ์ฅ๋์์ ์ธ ๋ฒ์งธ ์ฅ๋๋ก
www.acmicpc.net
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- 3๊ฐ ์ฅ๋์ N๊ฐ์ ์ํ์ด ์๋ ํ๋
ธ์ดํ ๋ฌธ์ ๋ฅผ ๊ตฌํํ๋ค.
- ์ํ์ ์ฎ๊ธด ํ์๋ฅผ ์ถ๋ ฅํ๋ค.
- ์ํ์ ์ฎ๊ธธ ๋๋ฅผ ์ฌ๊ท๋ก ๋๋ ๊ตฌํํ๋ค.
- ์ํ์ ๋์ด๊ฐ 1์ผ๋์ ๊ทธ๋ณด๋ค ํด ๋๋ก ๋๋ ์๊ฐํ๋ค.
- ์๋ฅผ ๋ค์ด 2๊ฐ์ ์ํ์ ์ฎ๊ธธ ๋,
- ์ฒซ ์ํ์ ์์ ์ง์ ์ ๋๋๋ค.
- ๋ ๋ฒ์งธ ์ํ์ ๋ชฉ์ ์ง์ ๋๋๋ค.
- ์ฒซ ์ํ์ ๋ชฉ์ ์ง์ ๋ ๋ฒ์งธ ์ํ ์์ ๋๋๋ค.
- ๋ฐ๋ผ์ ์ธ ๋ง๋๋ฅผ ์์, ์์, ๋ชฉ์ ์ธ ์ง์ ์ผ๋ก ๋๋ ์ฌ๊ท์ ์ผ๋ก ์๊ฐ ํ ์ ์๋ค.
- N์ด ๋๋ฌด ์ปค์ง๋ฉด ์ฌ๊ท๊ฐ์ด ๋๋ฌด ์ปค์ง๋ฏ๋ก ์ด ๋ฌธ์ ๋ 20๋ณด๋ค ํฌ๋ฉด ๊ณผ์ ์ถ๋ ฅ์ ์๋ตํ๋ค.
- ํ๋ ธ์ด ํ์ ์ด๋ ํ์๋ 2^N-1์ธ๋ฐ, N์ด 100๊น์ง ๊ฐ๋ฏ๋ก ์ด๋ ํ์๊ฐ int๋ longํ์ ์ด๊ณผํ๊ฒ ๋๋ค.
- ๋ฐ๋ผ์ ํฐ ์ ์ฐ์ฐ์ด ํ์ํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
public class Main {
private static int N;
private static StringBuilder sb;
public static void main(String[] args) throws IOException {
// Input
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
// Recursion
BigInteger bigInteger1 = new BigInteger("1");
BigInteger bigInteger2 = new BigInteger("2");
for (int i = 0; i < N; i++) {
bigInteger1 = bigInteger1.multiply(bigInteger2);
}
System.out.println(bigInteger1.subtract(new BigInteger("1")));
if (N <= 20) {
sb = new StringBuilder();
hanoi(N, 1, 2, 3);
System.out.print(sb);
}
}
private static void hanoi(int n, int s, int t, int e){
if (n == 1) {
sb.append(s).append(' ').append(e).append('\n');
return;
}
hanoi(n-1, s, e, t);
hanoi(1, s, t, e);
hanoi(n-1, t, s, e);
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ํฐ ์ ์ฐ์ฐ์ ์ํด BigInteger๋ฅผ ์ฌ์ฉํ๋ค.
- 2^N - 1 ์ ๊ณ์ฐํด ์ถ๋ ฅํ๋ค.
- N์ด 20๋ณด๋ค ์์ ๊ฒฝ์ฐ, ์ฌ๊ท๋ก ๊ณผ์ ์ ์ถ๋ ฅํ๋ค.
- n์ด 1์ด ๋ ๊ฒฝ์ฐ๋ ์์์ง s ์์ ๋์ฐฉ์ง e๋ก ์ฎ๊ธฐ๋ฉด ๋๋ค.
- n์ด 1๋ณด๋ค ํฐ ๊ฒฝ์ฐ๋ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ผ๋ก ์ฌ๊ท ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
- ๋ฐ ๋ฐ๋ฅ ์ํ์ ์์ชฝ์ ์์ ์ง์ ์ผ๋ก ์ฎ๊ธด๋ค.
- ๋ฐ ๋ฐ๋ฅ ์ํ์ ๋ชฉ์ ์ง๋ก ์ฎ๊ธด๋ค.
- ์์ ์ง์ ์ ์ํ์ ๋ค์ ๋ชฉ์ ์ง์ ๋ฐ ๋ฐ๋ฅ ์ํ ์๋ก ์ฎ๊ธด๋ค.
๐ธ end ๐ธ
- ์ด์ ์ ๋ต์ ๋ณด๊ณ ํ์์ด์ ๋ค์ ํ์ด๋ณด์๋ค.
- ์ฌ๊ท ๋ฉ์๋ ๊ตฌํ์ ์ข์ ์ฐ์ต์ด ๋๋ ๊ฒ ๊ฐ๋ค.
728x90