๋ฌธ์ ๋ถ์
์ผ๋จ, ํ๋ ธ์ด ํ์ด๋ ์์ ์ค๋ช ์ ๋ณด๋ฉด ์๊ฒ ์ง๋ง, ์กฐ๊ฑด์ด ๋๊ฐ์ง๊ฐ ์๋ค.
- ํ๋ฒ์ ํ ์ํ๋ง ์ฎ๊ธธ ์ ์๋ค.
- ์๋์ ์ํ์ ํญ์ ์์ ์ํ๋ณด๋ค ํฌ๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ณผ์ฐ ์ด๋ป๊ฒ ์ฎ๊ฒจ์ผ ํ ๊น? ์ผ๋จ ์ํ 3๊ฐ๋ฅผ ๊ฐ์ง๊ณ ๊ท์น์ ์ดํด๋ณด์.
1. ์ผ๋จ 1๋ฒ์งธ ํ์์์ 3๋ฒ์งธ ํ์๋ก 3๊ฐ์ ์ํ์ ์ฎ๊ธฐ๊ธฐ ์ํด์๋ ๊ทธ ์์ ์๋ ๋๊ฐ์ ์ํ์ ๋จผ์ ๊ฐ์ด๋ฐ๋ก ์ฎ๊ฒจ์ผ ํ๋ค. ( 5๋ฒ ๊ทธ๋ฆผ ์ฐธ์กฐ)
2. ๊ฐ์ฅ ์์ ์ํ์ ์ธ๋ฒ์งธ๋ก ์ฎ๊ฒผ๋ค.
3. 1๋ฒ ํ์์๋ ๊ฐ์ฅ ํฐ ์ํ, 2๋ฒ ํ์์๋ ์ค๊ฐ ํฌ๊ธฐ ์ํ, 3๋ฒ ํ์์๋ ๊ฐ์ฅ ์์ ์ํ์ด ์๋ค.
์. ์ด์ ์ด๋ป๊ฒ ๋๋ ์ดํด๋ณด์. ๋๋์ด ๊ฐ์ฅ ํฐ ์ํ์ด ์ํ๋ 3๋ฒ ํ์์ ๊ฐ ์ ์๊ฒ ๋๋ค.
์ด๋ก์จ ์ฐ๋ฆฌ๊ฐ ์ ์ ์๋ ์ ์, ๊ฐ์ฅ ํฐ ์ํ์ด 3๋ฒ ํ์(๋ชฉํ ์ง์ )์ ๊ฐ๊ธฐ ์ํด์๋ ๊ฐ์ฅ ํฐ ์ํ์ ์ ์ธํ ๋๋จธ์ง ๋ ์ํ์ด 2๋ฒ ํ์๋ก ์ฎ๊ฒจ์ ธ์ผ ์ด๋ ํ ์ ์๊ฒ ๋๋ค!
์ฝ๋ ๊ตฌํ
3๊ฐ์ ์ํ์ ์ด๋ ์ํค๊ธฐ ์ํด์๋?
move(N , 1, 3, 2);
๋งค๊ฐ๋ณ์๋ก ์ํ์ ๊ฐ์, ํ์ฌ ํ์ ๋ฒํธ, ๋ชฉํ ํ์ ๋ฒํธ, ์๋ธ ํ์ ๋ฒํธ ์ด๋ ๊ฒ ๋๊ฒจ์ค๋ค.
์๊น 5๋ฒ ๊ทธ๋ฆผ์์ ์๊ฒ ๋ ๊ฐ์ฅ ๋ฐ์ ์ํ์ ์ ์ธํ ๋๋จธ์ง ๋๊ฐ์ ์ํ์ด 2๋ฒ ํ์๋ก ์ฎ๊ฒจ์ ธ์ผ๋ง ๊ฐ์ฅ ํฐ ์ํ์ด ๋ชฉํ ํ์๋ก ์ด๋ ํ ์ ์๊ฒ ๋์๋ค.
๊ทธ๋ฅ ๋จ์ํ๊ฒ ๋๊ฐ์ ์ํ์ด ์๋ค๊ณ ๊ฐ์ ํ๊ณ , ๊ทธ ๋๊ฐ์ ์ํ์ 2๋ฒ ํ์์ ์ฎ๊ฒจ์ผ ํ๋ค๊ณ ์๊ฐํด๋ณด์.
๊ทธ๋ ๋ค๋ฉด ์ฌ๊ธฐ์ ๊ฐ์ฅ ํฐ ์ํ์ ์ค๊ฐ ํฌ๊ธฐ์ ์ํ์ด ๋ ๊ฒ์ด๊ณ , ๊ทธ๋ ๋ค๋ฉด ๋ ๊ฐ์ฅ ํฐ ์ํ์ ์ฎ๊ธฐ๋ ค๋ฉด ์ญ์ ๋๋จธ์ง ์ํ์ 2๋ฒํ์๊ฐ ์๋ 3๋ฒ ํ์์ ์ฎ๊ฒจ๋์์ผ ํ๋ค. ๊ทธ๋ ๋ค๋ฉด ์๋์ ๊ทธ๋ฆผ์ฒ๋ผ ๋ ๊ฒ์ด๋ค.
์ฝ๋๋ก ํํ ํ๋ฉด,
move(N-1, 1, 2, 3);
์ด ๋ถ๋ถ์ ๊ณ์ ์ํ์ ๊ฐ์๊ฐ 1์ด ๋ ๋๊น์ง ์ฌ๊ท๋ก ํธ์ถ ํ๊ฒ ๋๋ ๊ฒ์ด๋ค. ์ฌ๊ท๋ก ํํ ๋๋ ์์ ๋ณด๋ฉด,
// start : 1, sub : 2, end : 3
move(3, start, end, sub);
-> move(2, start, sub, end);
-> move(1, start, end, sub);
print(start + " -> " + sub);
-> move(1, end, sub, start);
print(start + " -> " + end);
-> move(2, sub, end, start);
-> move(1, start, end, sub);
print(start + " -> " + end);
-> move(1, end, sub, start);
์ ์ฒด ์ฝ๋
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
move(N, 1, 3, 2); // 3๊ฐ์ ์ํ์ 1๋ฒํ์์์ 3๋ฒ ํ์๋ก ์ฎ๊ธฐ๊ณ 2๋ฒ ํ์๋ ์๋ธ๋ก ์ฌ์ฉ.
}
private static void move(int N, int start, int end, int sub) {
if( N==1 ) {
System.out.println(start + " -> " + end);
return ;
}
move(N-1, start, sub, end); // N-1๊ฐ๋ฅผ ๋ชฉํ ์ง์ ์ด ์๋ ํ์์๋ค๊ฐ ์ฎ๊ฒจ ๋์ผ ๊ฐ์ฅ ํฐ ์ํ์ ์ฎ๊ธธ ์ ์๊ฒ ์ฃ ?
move(1, start, end, sub); // ์์ move ๋ฉ์๋๊ฐ ๋๋๋ฉด, sub์ ๋๋จธ์ง ์ํ์ด ์์ฌ์๊ณ , 3๋ฒ ํ์์๋ ๋น์์๊ฒ ๋์ด์ ๋ฐ๋ก ํฐ ์ํ์ ์ฎ๊ธฐ๋ฉด ๋๋ค.
move(N-1, sub, end, start); // ์๊น ์ฎ๊ฒจ ๋์๋ ์ํ์ ๋ค์ sub -> end ํ์๋ก ์ฎ๊ธฐ๋ ํธ์ถ์ ํ๋ค.
}
}