https://www.acmicpc.net/problem/3190
๋ฌธ์
'Dummy' ๋ผ๋ ๋์ค๊ฒ์์ด ์๋ค. ์ด ๊ฒ์์๋ ๋ฑ์ด ๋์์ ๊ธฐ์ด๋ค๋๋๋ฐ, ์ฌ๊ณผ๋ฅผ ๋จน์ผ๋ฉด ๋ฑ ๊ธธ์ด๊ฐ ๋์ด๋๋ค. ๋ฑ์ด ์ด๋ฆฌ์ ๋ฆฌ ๊ธฐ์ด๋ค๋๋ค๊ฐ ๋ฒฝ ๋๋ ์๊ธฐ์์ ์ ๋ชธ๊ณผ ๋ถ๋ชํ๋ฉด ๊ฒ์์ด ๋๋๋ค.
๊ฒ์์ NxN ์ ์ฌ๊ฐ ๋ณด๋์์์ ์งํ๋๊ณ , ๋ช๋ช ์นธ์๋ ์ฌ๊ณผ๊ฐ ๋์ฌ์ ธ ์๋ค. ๋ณด๋์ ์ํ์ข์ฐ ๋์ ๋ฒฝ์ด ์๋ค. ๊ฒ์์ด ์์ํ ๋ ๋ฑ์ ๋งจ์ ๋งจ์ข์ธก์ ์์นํ๊ณ ๋ฑ์ ๊ธธ์ด๋ 1 ์ด๋ค. ๋ฑ์ ์ฒ์์ ์ค๋ฅธ์ชฝ์ ํฅํ๋ค.
๋ฑ์ ๋งค ์ด๋ง๋ค ์ด๋์ ํ๋๋ฐ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ ๋ฐ๋ฅธ๋ค.
- ๋จผ์ ๋ฑ์ ๋ชธ๊ธธ์ด๋ฅผ ๋๋ ค ๋จธ๋ฆฌ๋ฅผ ๋ค์์นธ์ ์์น์ํจ๋ค.
- ๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๊ทธ ์นธ์ ์๋ ์ฌ๊ณผ๊ฐ ์์ด์ง๊ณ ๊ผฌ๋ฆฌ๋ ์์ง์ด์ง ์๋๋ค.
- ๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๋ชธ๊ธธ์ด๋ฅผ ์ค์ฌ์ ๊ผฌ๋ฆฌ๊ฐ ์์นํ ์นธ์ ๋น์์ค๋ค. ์ฆ, ๋ชธ๊ธธ์ด๋ ๋ณํ์ง ์๋๋ค.
์ฌ๊ณผ์ ์์น์ ๋ฑ์ ์ด๋๊ฒฝ๋ก๊ฐ ์ฃผ์ด์ง ๋ ์ด ๊ฒ์์ด ๋ช ์ด์ ๋๋๋์ง ๊ณ์ฐํ๋ผ.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ณด๋์ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค. (\(2 \leq N \leq 100\)) ๋ค์ ์ค์ ์ฌ๊ณผ์ ๊ฐ์ K๊ฐ ์ฃผ์ด์ง๋ค. (\(0 \leq K \leq 100\))
๋ค์ K๊ฐ์ ์ค์๋ ์ฌ๊ณผ์ ์์น๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ฒซ ๋ฒ์งธ ์ ์๋ ํ, ๋ ๋ฒ์งธ ์ ์๋ ์ด ์์น๋ฅผ ์๋ฏธํ๋ค. ์ฌ๊ณผ์ ์์น๋ ๋ชจ๋ ๋ค๋ฅด๋ฉฐ, ๋งจ ์ ๋งจ ์ข์ธก (1ํ 1์ด) ์๋ ์ฌ๊ณผ๊ฐ ์๋ค.
๋ค์ ์ค์๋ ๋ฑ์ ๋ฐฉํฅ ๋ณํ ํ์ L ์ด ์ฃผ์ด์ง๋ค. (\(1 \leq L \leq 100\))
๋ค์ L๊ฐ์ ์ค์๋ ๋ฑ์ ๋ฐฉํฅ ๋ณํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ ์ X์ ๋ฌธ์ C๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ. ๊ฒ์ ์์ ์๊ฐ์ผ๋ก๋ถํฐ X์ด๊ฐ ๋๋ ๋ค์ ์ผ์ชฝ(C๊ฐ 'L') ๋๋ ์ค๋ฅธ์ชฝ(C๊ฐ 'D')๋ก 90๋ ๋ฐฉํฅ์ ํ์ ์ํจ๋ค๋ ๋ป์ด๋ค. X๋ 10,000 ์ดํ์ ์์ ์ ์์ด๋ฉฐ, ๋ฐฉํฅ ์ ํ ์ ๋ณด๋ X๊ฐ ์ฆ๊ฐํ๋ ์์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฒ์์ด ๋ช ์ด์ ๋๋๋์ง ์ถ๋ ฅํ๋ค.
ํ์ด
๊ตฌํ ๋ฌธ์
์ด๋ ๋ฐฉํฅ์ ์ด๋ ๊ฒ ๋์ด์
index | 0 | 1 | 2 | 3 |
๋ฐฉํฅ | โก๏ธ | โฌ๏ธ | โฌ ๏ธ | โฌ๏ธ |
dx | 0 | 1 | 0 | -1 |
dy | 1 | 0 | -1 | 0 |
"D" ๐ ์ค๋ฅธ์ชฝ์ผ๋ก 90๋ ๐ index + 1
"L" ๐ ์ผ์ชฝ์ผ๋ก 90๋ ๐ index - 1
๋ฑ์ด ์์ผ๋ก ๋์๊ฐ๋ฉด์ ๋จธ๋ฆฌ(head) ๊ฐ ๋น๋ํ ๊ณณ์ด ๋ฒฝ์ด๊ฑฐ๋ ์๊ธฐ ์์ ์ ๋ชธ (-1)์ ๋๋ฌํ๋ฉด ์ข ๋ฃ โผ๏ธ
์ฝ๋
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;
public class Main_BOJ_3190_๋ฑ {
static class pair{
int x;
int y;
pair(int x, int y){
this.x = x;
this.y = y;
}
}
static int N, K, L;
static int[][] map;
static List<pair> tDirs;
static Queue<pair> snake;
static int[] dx = {0, 1, 0, -1};
static int[] dy = {1, 0, -1, 0};
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer stringTokenizer;
N = Integer.parseInt(br.readLine());
K = Integer.parseInt(br.readLine());
map = new int[N][N];
tDirs = new ArrayList<>();
snake = new LinkedList<>();
for(int i = 0 ; i < K ; i++){
stringTokenizer = new StringTokenizer(br.readLine());
int x = Integer.parseInt(stringTokenizer.nextToken());
int y = Integer.parseInt(stringTokenizer.nextToken());
map[x-1][y-1] = 1;
}
L = Integer.parseInt(br.readLine());
for(int i = 0; i < L; i++){
stringTokenizer = new StringTokenizer(br.readLine());
int t = Integer.parseInt(stringTokenizer.nextToken());
String d = stringTokenizer.nextToken();
int dir = d.equals("D") ? 1 : -1;
tDirs.add(new pair(t, dir));
}
map[0][0] = -1; // ๋ฑ
int time = 0, turn = 0;
int curdir = 0;
pair head = new pair(0, 0);
snake.add(head);
while(true){
time++;
int nx = head.x + dx[curdir];
int ny = head.y + dy[curdir];
if(nx < 0 || N <= nx || ny < 0 || N <= ny || map[nx][ny] == -1) break;
if(map[nx][ny] != 1){
pair tail = snake.poll();
map[tail.x][tail.y] = 0;
}
head = new pair(nx, ny);
snake.add(head);
map[nx][ny] = -1;
if(turn < L && tDirs.get(turn).x == time){
curdir = (curdir + tDirs.get(turn).y) % 4;
curdir = curdir == -1 ? 3 : curdir;
turn++;
}
}
System.out.println(time);
}
}
'์๊ณ ๋ฆฌ์ฆ > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ๋ฐฑ์ค / BOJ 16953 ] A -> B ( JAVA / ์๋ฐ ) (0) | 2021.11.02 |
---|---|
[ ๋ฐฑ์ค / BOJ 1484 ] ๋ค์ด์ดํธ ( ์๋ฐ / JAVA ) (0) | 2021.11.02 |
[ ๋ฐฑ์ค / BOJ 9461 ] ํ๋๋ฐ ์์ด ( ์๋ฐ / JAVA ) (0) | 2021.11.02 |
[ ๋ฐฑ์ค / BOJ 16943 ] ์ซ์ ์ฌ๋ฐฐ์น ( ์๋ฐ / JAVA ) (0) | 2021.10.28 |
[ ๋ฐฑ์ค / BOJ 18405 ] ๊ฒฝ์์ ์ ์ผ ( ์๋ฐ / JAVA ) (0) | 2021.10.28 |