๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ ๋ฌธ์ ์ด๋ฆ ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
1063๋ฒ: ํน
8*8ํฌ๊ธฐ์ ์ฒด์คํ์ ์์ด ํ๋ ์๋ค. ํน์ ํ์ฌ ์์น๊ฐ ์ฃผ์ด์ง๋ค. ์ฒด์คํ์์ ๋ง์ ์์น๋ ๋ค์๊ณผ ๊ฐ์ด ์ฃผ์ด์ง๋ค. ์ํ๋ฒณ ํ๋์ ์ซ์ ํ๋๋ก ์ด๋ฃจ์ด์ ธ ์๋๋ฐ, ์ํ๋ฒณ์ ์ด์ ์์งํ๊ณ , ์ซ์๋
www.acmicpc.net
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง๋ฅผ ๋จผ์ ์๊ฐํด๋ณด์.
๋ฌธ์ ์ ๊ทผ
์ด ๋ฌธ์ ๋ 8 * 8
์ฒด์คํ์์ ํ๋์ ์ฒด์ค (King)์ด ์๋๋ฐ, ํด๋น ์ฒด์ค๊ฐ ๋ ๊ฐ์ง ์ ์ฝ ์กฐ๊ฑด์ ๋ฐ๋ผ ์์ง์ผ ๋๋ฅผ ๊ตฌํํ๋ ๊ฒ์ด๋ค.
์ ์ฝ ์กฐ๊ฑด์๋ 2๊ฐ์ง๊ฐ ์๋ค.
- ํน๊ณผ ๋์ 8 by 8 ์ฒด์คํ์ ๋ฒ์ด๋ ์ ์๋ค. ๋ ์ค ํ๋๋ผ๋ ๋ฒ์ด๋๋ค๋ฉด ์์ ์์ง์ด์ง ์๋๋ค.
- ํน์ด ์์ง์ผ ๊ณณ์ ๋์ด ์์นํ๋ค๋ฉด ํน์ด ๋์ ์์น๋ก ์์นํ๊ฒ ๋๊ณ ๋์ด ํน์ด ๊ฐ๋ ค๊ณ ํ๋ ์์น๋งํผ ์ด๋ํ๋ค.
ํด๊ฒฐ๋ฒ
๊ทธ๋ผ ์ฐ์ ์ด๋ค ๊ฒ๋ค์ด ํ์ํ ์ง๋ฅผ ์๊ฐํด๋ณด์.
- ์์ง์ด๋ ค๋ ๊ณณ์ด ์ฒด์ค ํ ๋ด๋ถ์ธ๊ฐ, ์ฆ ์ ํจํ ์์ง์์ธ๊ฐ?
mapValidation()
- ์ฌ์ฉ์๋ ์ด๋ค ๋ช
๋ น์ ์ฃผ๊ณ ์์ผ๋ฉฐ ์ผ๋งํผ ์์ง์ผ ๊ฒ์ธ๊ฐ?
getMovement()
- A1, G2, D5 ์ ๊ฐ์ ์ฒด์ค ๋งต์ ์ด๋ป๊ฒ ๋ฐฐ์ด๋ก ํ์ํ ๊ฒ์ธ๊ฐ?
updatePositioin()
์ค๋ต ํ๋ณด
๋์๊ฒ ์ด๋ฒ ๋ฌธ์ ์์ ๊ฐ์ฅ ํฐ ์ด๋ ค์์ ์๋ฌธ๊ณผ ์ซ์์ ์กฐํฉ์ผ๋ก ๋ x, y ์ขํ๋ฅผ ์ซ์ ์ขํ๋ก ๋ฐ๊พธ๋ ๊ฒ์ด์๋ค.
๊ทธ๋์ ๋ค์ ๋ณต์กํ ์์คํค ์ฝ๋๋ฅผ ์ด์ฉํ์ฌ ํ์ด๋ฅผ ํ๋๋ฐ, ์ด ์ ์ ์ ์ํ๋ฉด ๋ ๊ฒ ๊ฐ๋ค.
์ ๋ต ์ฝ๋
public class Main {
private static int[][] movements = {
{1, 0}, // 0 : R ์ค๋ฅธ์ชฝ์ผ๋ก
{-1, 0}, // 1 : L ์ผ์ชฝ์ผ๋ก
{0, 1}, // 2 : B ์๋๋ก
{0, -1}, // 3: T ์๋ก
{1, -1}, // 4 : RT ์ค๋ฅธ์ชฝ ๋๊ฐ์ ์๋ก
{-1, -1}, // 5 : LT ์ผ์ชฝ ๋๊ฐ์ ์๋ก
{1, 1}, // 6 : RB ์ค๋ฅธ์ชฝ ์๋ ๋๊ฐ
{-1, 1} // 7 : LB ์ผ์ชฝ ์๋ ๋๊ฐ
};
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] inputs = br.readLine().split(" ");
String[] kingPosition = inputs[0].split("");
String[] stonePosition = inputs[1].split("");
int loop = Integer.parseInt(inputs[2]);
while(loop-- > 0) {
String move = br.readLine();
int kingX = kingPosition[0].charAt(0) - 65; // A = 0 B = 1 x
int kingY = Math.abs(Integer.parseInt(kingPosition[1]) - 8); // 1 = 7 2 = 6 y
int stoneX = stonePosition[0].charAt(0) - 65;
int stoneY = Math.abs(Integer.parseInt(stonePosition[1]) - 8);
int movementIndex = getMovement(move);
boolean flag = false;
if(mapValidator(movements[movementIndex], kingX, kingY)) {
int xx = kingX + movements[movementIndex][0];
int yy = kingY + movements[movementIndex][1];
if(xx == stoneX && yy == stoneY) {
if(mapValidator(movements[movementIndex], stoneX, stoneY)) {
kingX = stoneX; kingY = stoneY;
stoneX += movements[movementIndex][0]; stoneY += movements[movementIndex][1];
}
flag = true;
}
if(!flag) {
kingX += movements[movementIndex][0];
kingY += movements[movementIndex][1];
}
}
updatePosition(kingPosition, kingX, kingY);
updatePosition(stonePosition, stoneX, stoneY);
}
System.out.println(kingPosition[0] + kingPosition[1] +"\n" + stonePosition[0] + stonePosition[1]);
}
private static void updatePosition(String[] position, int x, int y) {
position[0] = String.valueOf((char) (x + 65));
position[1] = String.valueOf(Math.abs(y - 8));
}
private static boolean mapValidator(int[] movement, int x, int y) {
int xx = movement[0] + x;
int yy = movement[1] + y;
return 0 <= xx && xx < 8 && yy >= 0 && yy < 8;
}
private static int getMovement(String move) {
if(move.equals("R")) {
return 0;
}else if(move.equals("L")) {
return 1;
}else if(move.equals("B")) {
return 2;
}else if(move.equals("T")) {
return 3;
}else if(move.equals("RT")) {
return 4;
}else if(move.equals("LT")) {
return 5;
}else if(move.equals("RB")) {
return 6;
}else if(move.equals("LB")) {
return 7;
}
else return Integer.MAX_VALUE;
}
}
๋ฌธ์ ํ๊ณ
์ด๋ฒ ๋ฌธ์ ๋ ์ค๋ฒ 5์ธ๋ฐ ์์ฒญ ์ค๋ ๊ฑธ๋ฆฐ ๋ฌธ์ ์ด๋ค.
์๋ง ์์ฃผ ์ค๋๋ง์ ๋ค์ ์์ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ String to Char ๋ ๊ธฐ์ต๋ ์ ๋ฌ์ผ๋ฉฐ ์์คํค ์ฝ๋๊น์ง ๊น๋จน๊ณ ์์์ ํด์ ๋ค์ ์ฐพ์๋ณด๋๋ผ ๋ ์ค๋ ๊ฑธ๋ฆฐ ๊ฒ ๊ฐ๊ธฐ๋ ํ๋ค.
์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ ๊ฐ์ฅ ๊ทผ๋ณธ์ ์ธ ์ด์ ๋ ๋ด ๊ฐ๋ฐ ํผ์ง์ปฌ ๋๋ฌธ์ด ์๋๊น ์ถ๋ค.
๋์ถฉ ์ด๋ป๊ฒ ํด์ผ ํ๋ค๋ผ๋ ๊ฒ์ ์๊ฒ ์ง๋ง ์ด๋ฅผ ์ง์ ๊ตฌํํ๋๊ฒ ์ฐธ ๊น๋ค๋กญ๋ค.
๋๊ธ