Tags
- ๊ทธ๋ํ ํ์
- Brute Force Algorithm
- dfs
- CodingTest
- ๋๋น ์ฐ์ ํ์
- ๊ตฌํ
- DP
- ์ํ
- ๊ทธ๋ํ ์ด๋ก
- PGM
- ์ ๋ ฌ
- greedy
- ์ ์๋ก
- sort
- BFS
- ๋ฌธ์์ด
- Study
- ๊น์ด ์ฐ์ ํ์
- Dynamic Programming
- SpringBoot
- BOJ
- queue
- LV2
- ๊ต์ฌ
- Java
- stack
- ์๋ฎฌ๋ ์ด์
- Python
- ์๋ฃ๊ตฌ์กฐ
- ๋ฐฑํธ๋ํน
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_15685 : ๋๋๊ณค ์ปค๋ธ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- ์ขํ๊ฐ 0๋ถํฐ ์์ํ๋ 101 x 101 ๊ฒฉ์ํ์ด ์๋ค.
- N๋ฒ์ ๋๋๊ณค ์ปค๋ธ๋ฅผ ์ํํ ํ์ ํ ๊ฒฉ์์ ๋ค ๊ผญ์ง์ ์ด ๋ชจ๋ ๋๋๊ณค ์ปค๋ธ์ ํฌํจ ๋ ์นธ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
- ๋๋๊ณค ์ปค๋ธ๋ ์ธ๋๋ฅผ ๊ฑธ์น ์๋ก ์ด์ ์ธ๋์ ๋ง์ง๋ง ์ ์ ๊ธฐ์ค์ผ๋ก ๊ธฐ์กด ์ปค๋ธ ๊ทธ๋ฆผ์ 90๋ ์๊ณ๋ฐฉํฅ์ผ๋ก ๋๋ ค ์ถ๊ฐ๋ก ์ด์ด ๊ทธ๋ฆฌ๋ ๊ฒ์ด๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ๋จ์ ๊ตฌํ/์๋ฎฌ๋ ์ด์ ๋ฌธ์ ์ด๋ค. ์ธ๋๋ฅผ ๋ฐ๋ณต ํ ๋, ์ด์ ์ธ๋์ ํ์ ์ ๋ณด๊ฐ ํ์ํ๋ค. ๋ฐ๋ผ์ ํ์ ์ ๋ณด๋ฅผ ๋์ ํด์ ์ ์ฅํด์ผ ํ๋๋ฐ, ๊ทธ ํฌ๊ธฐ๋ 2^์ธ๋ ์์ด๋ค.
- ์ธ๋๋ฅผ ๋ฐ๋ณต ํ ๋๋ง๋ค ์ด์ ํ์ ์ ๋ณด๋ฅผ ์ญ์์ผ๋ก ์กฐํํด์ ๋๋๊ณค ์ปค๋ธ๋ฅผ ๊ณ์ฐํ๋ฉด ๋๋ค.
- ๋ง์ง๋ง์ผ๋ก ์นธ์ ๊ฐ์๋ฅผ ์นด์ดํธ ํ ๋๋ ์ผ์ชฝ ์ ๊ผญ์ง์ ์ ๊ธฐ์ค์ผ๋ก ๊ฒฉ์ํ์ ๋ฒ์๋ฅผ ๋ฒ์ด๋์ง ์๊ฒ ์กฐํํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
import java.util.StringTokenizer;
public class Main {
private static final int[] dx = {1, 0, -1, 0};
private static final int[] dy = {0, -1, 0, 1};
private static final int MAX = 100;
private static boolean[][] board;
private static int[] curves;
public static void main(String[] args) throws IOException {
// Input
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st;
int N = Integer.parseInt(br.readLine());
board = new boolean[MAX + 1][MAX + 1];
// Draw
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken()); // ์์ col ์ขํ
int y = Integer.parseInt(st.nextToken()); // ์์ row ์ขํ
int d = Integer.parseInt(st.nextToken()); // ์์ ๋ฐฉํฅ
int g = Integer.parseInt(st.nextToken()); // ๋๋๊ณค ์ปค๋ธ ์ธ๋์ ์
curves = new int[(int) Math.pow(2, g)];
curves[0] = d;
draw(y, x, g);
}
// Count
int cnt = 0;
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++) {
if (board[i][j] && board[i][j + 1] && board[i + 1][j] && board[i + 1][j + 1]) {
cnt++;
}
}
}
// Output
bw.write(Integer.toString(cnt));
bw.flush();
}
private static void draw(int row, int col, int g) {
int idx = 0;
int d = curves[idx];
board[row][col] = true;
row += dy[d];
col += dx[d];
board[row][col] = true;
for (int i = 1; i <= g; i++) { // 1 ~ g์ธ๋ ๊ณ์ฐ
for (int j = idx; j >= 0; j--) { // ์ญ์์ผ๋ก ์ ์ฅ๋ ๋ฐฉํฅ ํ์ธ
d = (curves[j] + 1) % 4; // ์๋ก์ด ๋ฐฉํฅ
curves[++idx] = d;
row += dy[d];
col += dx[d];
board[row][col] = true;
}
}
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ๋ฌธ์ ์์ ์ ์ ๋ ๋ฐฉํฅ ์ ๋ณด(์ฐ์์ขํ)๋ฅผ dx, dy ๋ธํ ์ ๋ณด๋ก ์ ์ฅํด์ ์ฌ์ฉํ๋ค.
- ๊ฒฉ์ํ์ ๊ฐ ์นธ์ด ๋๋๊ณค ์ปค๋ธ์ ํฌํจ ๋๋์ง boolean 2์ฐจ์ ๋ฐฐ์ด board์ ์ ์ฅํ๋ค.
- ๋์ ํ์ ์ ๋ณด๋ฅผ int ๋ฐฐ์ด curves์ ์ ์ฅํ๋ค.
- draw() ๋ฉ์๋์์ ๋๋๊ณค ์ปค๋ธ๋ฅผ ๊ตฌํํด board์ ํ์ํ๋ค.
- ์ต์ด 0์ธ๋๋ ๋ฌด์กฐ๊ฑด ์์ผ๋ฏ๋ก ์์ ์ขํ์ ๋ค์ ์ขํ๋ฅผ board์ ํ์ํ๋ค
- ๋ค์ 1์ธ๋ ๋ถํฐ๋ ๋์ฐฉํ๋ ์ขํ๋ง board์ ํ์ํ๋ค.
- ๋๋๊ณค ์ปค๋ธ๋ฅผ ๋ชจ๋ ๊ทธ๋ฆฐ ํ์ ์ผ์ชฝ์ ๊ผญ์ง์ ์ ๊ธฐ์ค์ผ๋ก ๋ค ๊ผญ์ง์ ์ด ๋ชจ๋ true์ธ ์นธ์ ์ฐพ์ ์นด์ดํธํ๊ณ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ํน๋ณํ ์๊ณ ๋ฆฌ์ฆ์ด ์๋ ๊ตฌํ/์๋ฎฌ๋ ์ด์
๋ฌธ์ ์ฌ์ ๋งํ์์ด ํ์ด๋ฅผ ๋ ์ฌ๋ฆฌ๊ธด ํ๋ค.
- ํ์ง๋ง ๊ณ ๋ฏผ ์๊ฐ ์์ฒด๊ฐ ์ค๋ ๊ฑธ๋ ธ๊ณ , ๋๋ฒ๊น ๋ ๋๋๊ฒ ๋์ด์ 2์๊ฐ์ด ํ์ฉ ๋์ด์ ํ์๋ค.
- 0๋ฒ์งธ ์ธ๋์ ๊ทธ ์ดํ์ ์ธ๋๋ฅผ ๋ถ๋ฆฌํด์ ์๊ฐํ๊ธฐ๊น์ง๊ฐ ๊ฐ์ฅ ์ค๋ ๊ฑธ๋ฆฐ ๊ฒ ๊ฐ๋ค.
- ๋ง์ฐ์ค๋ ์์ด ๋ ธํธ๋ถ ํฐ์นํจ๋๋ก ํ์ดํด์ ๋ ๋๋ ค์ง๊ณ ์ง์ค๋ ฅ๋ ํ๋ ค์ง ๊ฒ ๊ฐ๋ค.
- curves์ ํฌ๊ธฐ ๊ณ์ฐ์ 2^์ธ๋์๋ก ์ ๊ณ์ฐํด ๋๊ณ , ๋๋ฒ๊น ๊ณผ์ ์์ 2^์ธ๋์+1๋ก ๋๋ ค์ ์ ์ถํ๋ค. ์์ ํด์ ๋ค์ ์ ์ถํ๋๋ผ 3๋ฒ ์ ์ถํด ๋ณด์๋ค.
- ํ์ด ๊ณํ์ ์ ์ด๊ฐ๋ฉฐ ํ์ดํ๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_1937 : ์์ฌ์์ด ํ๋ค (0) | 2024.06.10 |
---|---|
BOJ_2146 : ๋ค๋ฆฌ ๋ง๋ค๊ธฐ (0) | 2024.05.29 |
BOJ_11066 : ํ์ผ ํฉ์น๊ธฐ (0) | 2024.05.24 |
BOJ_11049 : ํ๋ ฌ ๊ณฑ์ ์์ (0) | 2024.05.23 |
BOJ_9466 : ํ ํ๋ก์ ํธ (0) | 2024.05.23 |