๋ฌธ์
0๊ณผ 1๋ก๋ง ์ด๋ฃจ์ด์ง ์๋ฅผ ์ด์ง์๋ผ ํ๋ค. ์ด๋ฌํ ์ด์ง์ ์ค ํน๋ณํ ์ฑ์ง์ ๊ฐ๋ ๊ฒ๋ค์ด ์๋๋ฐ, ์ด๋ค์ ์ด์น์(pinary number)๋ผ ํ๋ค. ์ด์น์๋ ๋ค์์ ์ฑ์ง์ ๋ง์กฑํ๋ค.
- ์ด์น์๋ 0์ผ๋ก ์์ํ์ง ์๋๋ค.
- ์ด์น์์์๋ 1์ด ๋ ๋ฒ ์ฐ์์ผ๋ก ๋ํ๋์ง ์๋๋ค. ์ฆ, 11์ ๋ถ๋ถ ๋ฌธ์์ด๋ก ๊ฐ์ง ์๋๋ค.
์๋ฅผ ๋ค๋ฉด 1, 10, 100, 101, 1000, 1001 ๋ฑ์ด ์ด์น์๊ฐ ๋๋ค. ํ์ง๋ง 0010101์ด๋ 101101์ ๊ฐ๊ฐ 1, 2๋ฒ ๊ท์น์ ์๋ฐฐ๋๋ฏ๋ก ์ด์น์๊ฐ ์๋๋ค.
N(1 โค N โค 90)์ด ์ฃผ์ด์ก์ ๋, N์๋ฆฌ ์ด์น์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
## ์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค.
## ์ถ๋ ฅ
์ฒซ์งธ ์ค์ N์๋ฆฌ ์ด์น์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ | ์ ์ถ | ์ ๋ต | ๋งํ ์ฌ๋ | ์ ๋ต ๋น์จ |
---|---|---|---|---|---|
2 ์ด | 128 MB | 91755 | 39024 | 29652 | 41.053% |
https://www.acmicpc.net/problem/2193
ํ์ด
๋ฐฉ๋ฒ 1 (์ญ์)
๋ฌธ์ ๋ฅผ ์ดํด๋ณด๋ฉด ์๋์ ๊ฐ์ด ๋๊ฐ์ง์ ๊ท์น์ ๋ณผ์์๋ค.
- ์ด์น์๋ 0์ผ๋ก ์์ํ์ง ์์.
- ์ด์น์๋ 1์ด ๋๋ฒ ์ฐ์์ผ๋ก ๋ํ๋์ง์์.
์ดํด๋ณด๋ฉด ์๋์ ๊ฐ์ด ์ค๋ช ํ ์์๋ค.
1) 4์๋ฆฌ์ ์ค 2๊ฐ๋ 3์๋ฆฌ์์ ๋ชจ๋ ๊ฐ์์ ๊ฐ๋ค.
2) 4์๋ฆฌ์ ์ค 1๊ฐ๋ 2์๋ฆฌ์์ ๋ชจ๋ ๊ฐ์์ ๊ฐ๋ค.
์ด๋ n=5
์ผ๋๋ ์ ์ฉ๋๋ค.
1) 5์๋ฆฌ์ ์ค 3๊ฐ๋ 4์๋ฆฌ์์ ๋ชจ๋ ๊ฐ์์ ๊ฐ๋ค.
2) 5์๋ฆฌ์ ์ค 2๊ฐ๋ 3์๋ฆฌ์์ ๋ชจ๋ ๊ฐ์์ ๊ฐ๋ค.
์ด๋ฅผ ํตํด ์ ํ์์ ๊ตฌํ๋ฉด
dp[n] = dp[n-1] + dp[n-2]
๋ค์์ผ๋ก ์ด๋ฌธ์ ๋ฅผ ๋ณด๋ฉด n์ ๋ฒ์๊ฐ 1~90๊น์ง ์ด๋ค. n=90์ผ ๊ฒฝ์ฐ๋ฅผ ๋ณด๋ฉด 46ํญ์ด ๋ ๋, 2971215073์ด ๋์ด,
int
์ ๋ฒ์๋ฅผ ์ด๊ณผํ๊ฒ ๋๋ค. ์ฆ, ํน์ ์๋ก ๋๋ ๋๋จธ์ง๊ฐ(๋ชจ๋๋ฌ)๋ฅผ ์ฌ์ฉํด์ ์ถ๋ ฅํ๊ฑฐ๋, int ์ด์์ ์๋ฃํ์ ์ด์ฉํด์ผํ๋ค. (์ดํด๊ฐ ์๊ฐ๋ค๋ฉด ๋ฌธ์ ์ ์ ํ์์ ๋ณด๋ฉด๋๋ค. ์ด ์ ํ์์ ํผ๋ณด๋์น์์ด๊ณผ ๊ฐ์๊ฒ์ ๋ณผ์์๋๋ฐ, ํผ๋ณด๋์น ์์ด์ ๋์ ํด์ ๊ณ์ฐํด๋ณด๋ฉด ๋ต์ด ๋์จ๋ค... ๊ธฐํ๊ธ์์ ์ผ๋ก ์ฆ๊ฐ๋๋ค.) ์ด์จ๋ ์ด๋ฌํ ์ด์ ๋๋ฌธ์long
์๋ฃํ์ ์ฌ์ฉํด์ผํ๋ค!
์ฝ๋
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
static int n;
static long dp[] = new long[91];
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
n = Integer.parseInt(br.readLine());
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i-1] + dp[i-2]; //์ ํ์ ๋์
.
}
System.out.println(dp[n]);
}
}
๋ค์ ๋ฐฉ๋ฒ๋ ์ดํด๋ณด์.
๋ฐฉ๋ฒ2(์ด์ฐจ์๋ฐฐ์ด)
์ดํด๋ณด๋ฉด, 3์๋ฆฌ์์์ 4์๋ฆฌ์๊ฐ ๋๋ ๋ถ๋ถ์ด๋ค. ์ด๋ ์ถ๊ฐ๋๋ ๋ถ๋ถ์ ๋นจ๊ฐ์์ผ๋ก ํ์ํ๊ฒ์ด๋ค.
๊ท์น์ ์ดํด๋ณด๋ฉด, ์ด์น์์์ 1์ด ๋๋ฒ ์ฐ์์ผ๋ก ๋ํ๋์ง ์์ผ๋ฏ๋ก 11
์ด ๋ํ๋๋๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค. ์ฆ ๋ง์ง๋ง์ ๋๋๋ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ดํด๋ณด๋ฉด ๋ ๊ฒ์ด๋ค. 3์๋ฆฌ์์์ ๋ง์ง๋ง์ ๋๋๋์๊ฐ 0์ผ ๊ฒฝ์ฐ์๋ 0,1 ์ด ๋ค์ด์ฌ์์๊ณ , 1์ผ๊ฒฝ์ฐ์๋ 0๋ง ๊ฐ๋ฅํ๋ค.
A : 0์ผ๋ก ์์๋๋ ๊ฒฝ์ฐ : 00 01 ๊ฐ๋ฅ
dp[4][0] = dp[3][0] + dp[3][1]
B: 1๋ก ์์๋๋ ๊ฒฝ์ฐ: 10 ๊ฐ๋ฅ
dp[4][1] = dp[3][0]
์ด๋ ๊ฒ ๋ํ๋ผ์ ์๊ฒ ๋ค. ์ด๋ฅผ ํตํด ์ ํ์์ ๋ฝ์๋ณด๋ฉด?
dp[n][0] = dp[n-1][0] + dp[n-1][1]
dp[n][1] = dp[n-1][0]
์ด๋ ๊ฒ ๋๋ ์ ๊ตฌํด์ง๊ฒ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ํฉ์ณ์ค๋ค๋ฉด ์ํ๋ ๋ต์ ๊ตฌํ ์์๋ค.
์ฝ๋
package ๊ธฐ์ด1.Day16.์ ํด์;
import java.util.Scanner;
public class ์ด์น์ {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[][] dp = new long[n+1][2]; //int ํ ์ ์ธ์์ ๋ฒ์๊ฐ ์ด๊ณผ๋๋ค.
/*
์ด๋ ๊ฒ ์ดํดํ์. n=2 ์ผ๋, 2์๋ฆฌ์ 00 01 10 11 ์ด๋ ๊ฒ ๋์ฌ๊ฒ์ด๋ค.
์ฌ๊ธฐ์ dp[์๋ฆฌ์][๋ง์ง๋ง๋ท์๋ฆฌ] = ์ด์น์์ ๊ฐ์ ๋ก ์ ์ธํ์.
์ฆ, dp[2][0] ์ด๋ผ๋ฉด {0}0 {0}1 ์ด๋ ๊ฒ ๋ ๊ฒ์ด๊ณ , ์ด์น์์ ๊ฐฏ์๋ 0์ด๋ค. ์๋ํ๋ฉด ์ ์ผ์์๋ 0์ผ์๊ฐ ์๊ธฐ๋๋ฌธ.
dp[2][1] ์ด๋ผ๋ฉด {1}0 {1}1 ์ด๋ ๊ฒ ๋ ๊ฒ์ด๋ค. ์ด์น์์ ๊ฐ์๋ 1์ด๋ค.
*/
dp[1][1] = 1;
dp[1][0] = 0;
for(int i=2; i<=n; i++){
dp[i][0] = dp[i-1][0] + dp[i-1][1]; //[4][0] -> {100}0, {100}1
dp[i][1] = dp[i-1][0]; // [4][1] -> {101}0 ์ด๋ฐ์์ผ๋ก...!
}
System.out.println(dp[n][0] + dp[n][1]);
sc.close();
}
}