์ฒ์์๋ String์ ํ์ฉํด ํ๋ฒ๊ฑฐ๊ตฌ์กฐ๋ฅผ ๋จ์ ์ฌ๊ท๋ก ๊ตฌํํ ๋ค ํจํฐ์ ๊ฐฏ์๋ฅผ ์ธ๋ ค๊ณ ํ๋ค. 2^n์ผ๋ก ์ฌ๊ท๊ฐ ๋ฐ๋ณต๋ผ ๋์ค์๋ ์ ๋ง ํฐ ๋ฌธ์์ด์ด ์๊ฒจ๋๋ค. ๋ฐ๋ผ์ ์๋ฌ๊ฐ ๋ฐ์ํ๊ฒ ๋๋ค.
๐ก ์กฐ๊ฑด์ ์ ์ง์ ๋ฐ์ฉ ์ค์ฌ๋๊ฐ๋ฉด์ ํจํฐ ์๋ฅผ ์ธ์ด๋๊ฐ๋ฉด ๋๋ค!
๐ก ๊ฒฝ์ฐ์ ์์ ๋ํ ์์ธํ ๊ท์น์ ์ฝ๋๋ก ํ์ธํํ๋ฉด ๋๋ค.
package Reculsive;
import java.util.Scanner;
//๋ ๋ฒจ-0 ๋ฒ๊ฑฐ๋ ํจํฐ๋ง์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
// ๋ ๋ฒจ-L ๋ฒ๊ฑฐ๋ B, ๋ ๋ฒจ-(L-1) ๋ฒ๊ฑฐ, P, ๋ ๋ฒจ-(L-1)๋ฒ๊ฑฐ,B์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. (L โฅ 1)
// ์๋ฅผ ๋ค์ด, ๋ ๋ฒจ-1 ๋ฒ๊ฑฐ๋ 'B P P P B', ๋ ๋ฒจ-2 ๋ฒ๊ฑฐ๋ 'B BPPPB P BPPPB B'์ ๊ฐ์ด ์๊ฒผ๋ค. (B๋ ํ๋ฒ๊ฑฐ๋ฒ, P๋ ํจํฐ)
//
// ์๋๊ฐ ์๊ทผ๋ ๋์ ๋ฐฉ๋ฌธํด์ ๋ ๋ฒจ-N ๋ฒ๊ฑฐ๋ฅผ ์์ผฐ๋ค. ์๋๊ฐ ํ๋ฒ๊ฑฐ์ ์๋ X์ฅ์ ๋จน์์ ๋, ๋จน์ ํจํฐ๋ ๋ช ์ฅ์ผ๊น? ํ ์ฅ์ ํ๋ฒ๊ฑฐ๋ฒ ๋๋ ํจํฐ ํ ์ฅ์ด๋ค.
public class Bj16974_LevelBurger {
private static long[] total;
private static long[] patty;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
long X = sc.nextLong();
total = new long[N+1];
patty = new long[N+1];
total[0] = 1 ; patty[0] = 1; // ์ด์ฌ๋ฃ์๋ ํจํฐ๊ฐฏ์ ๊ตฌํ๊ธฐ ์ํด ์ฒ์ ํจํฐํ์ฅ์๋๊ฑธ ์ด๊ธฐํ ํด์ค
for(int i = 1 ; i <= N ; i++) {
total[i] = 1+total[i-1]+1+total[i-1]+1;//N์ด 1, 2, 3,...์ผ ๊ฒฝ์ฐ๋ฅผ ์ฐจ๋ก๋ก ๋ฐฐ์ด์ ๊ฐฏ์๋ฅผ ์ ์ฅํด์ค
patty[i] = patty[i-1]+1+patty[i-1];//๋นต๋ง๊ณ ํจํฐ๋ง ๊ฐฏ์ ์ถ๊ฐ
}
System.out.println(CountPatty(N, X));
}
//1 p
//5 BPPPB
// BBPPPB P BPPPBB
public static long CountPatty(int N, long X) {
if(N==0) {
if(X==0) return 0; //๋ ๋ฒจ๋ 0์ด๊ณ ํ์ฅ๋ ์๋จน์์ ๊ฒฝ์ฐ
else return 1; //๋ ๋ฒจ 0์ธ๋ฐ ํ์ฅ ๋จน์์ ๊ฒฝ์ฐ
}
//N->0์ด ์๋๋ x์ฅ ๋จน์์๋ ๋จน์ ํจํฐ ์ ๊ตฌํ๊ธฐ
if(X==1) return 0;//์ผ๋จ ํ์ฅ ๋จน์ผ๋ฉด ๋งจ๋ฐ์ ๋นต์ด๋ผ ํจํฐ 0๊ฐ ๋จน์ ใ
ใ
else if(X <= 1+total[N-1] ) { //์ค์ ํจํฐ P๋ณด๋ค ์์ ๊ฒฝ์ฐ -> ํ์ฌ์ ๋ฐ์ ์ด์ ๋ ๋ฒจ์ ๋นตํ๋๋ง ๋ํ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ์ด์ ํธ์ถ +1(๋นต)์ ํด์ค๊ฒ
return CountPatty(N-1, X-1);//์ด์ ๋นต๋ณด๋ค ์๊ธฐ ๋๋ฌธ์ ์ด์ ๋นต์ผ๋ก ๋ค์๋น๊ตํ๊ธฐ ์ํด + x-1์ ๋งจ์์๋นต์ ์
ํ์๊ฐ ์์ด์
}else if(X == 1+total[N-1]+1 ) {//๋ฐ + 1(์ค์ํจํฐ) == X๊ฐ์ด ์ค์๊ฐ๊ณผ ๊ฐ์ ๋
return patty[N-1]+1;//์ด์ ๊ฑฐ ํจํฐ์ +1(ํจํฐ)๋ง ํด์ฃผ๋ฉด ๋จ
}else if(X < total[N]) {//๋ฐ +1(์ค์ํจํฐ) <= X๊ฐ์ด ์ค์๊ฐ๋ณด๋ค ํด๋
return patty[N-1]+1+CountPatty(N-1, X-(1+total[N-1]+1)); //๋ฐ๋ณด๋ค ํฌ๋ฉด ๋ฐ๊น์ง ์ด์ ๋ ๋ฒจํจํฐ๊ฐฏ์๋ก ์ธ๊ณ ๋๋จธ์งX๋ ์ด์ ๋ ๋ฒจ ์ด ์ฌ๋ฃ+๋นต+ํจํฐ๋งํผ ์ค์ธ๋ค์์ ์ฌ๊ทํ๋ฉด ๋๋ค.
}else {//X๊ฐ total ์ด๋ ๊ฐ์๋
return patty[N];
}
//N = 4, x = 5 // N=2 x=4
}
}