1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
KEY WORD
: BFS
, IDEA
ํด๋น ๋ฌธ์ ๋ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํ IDEA
๋ง ์๊ฐํด๋ธ๋ค๋ฉด ๊ฐ๋จํ BFS
๋ฌธ์ ์ด๋ค. ๋ฌธ์ ์ ๋ํ ์ ๊ทผ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ๋ค.
(1) ์ ๋ ฅ๋ฐ์ ์ขํ์ ๋ณ๋๋ฆฌ ๋ถ๋ถ๋ ํ์ธํธ๋ฅผ ์น ํ ์ ์๋ค. ๊ฐ๋ น
ํ๋์์ผ๋ก ์น ํ ๋ถ๋ถ์ ๋ด๋ผ. ๋ง์ฝ ์
๋ ฅ ์ขํ ๊ทธ๋๋ก 2์ฐจ์ ๋ฐฐ์ด์ ๋ง๋ ๋ค๋ฉด, ํด๋น ๋ณ๋๋ฆฌ ๋ถ๋ถ์ ๋ฐฐ์ด์ ๋ฒ์ด๋๊ฒ ๋์ด, ํ์ธํธ๋ฅผ ์น ํ ๋ ๊ณจ์น๊ฐ ์ํ์ง๋ค. (์์นซ ์๋ชปํ๋ฉด OutOfArrayIndex ์๋ฌ๊ฐ ๋๊ธฐ ๋๋ฌธ์ด๋ค!!)
๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ ํด๋น ์ขํ๋ ๋ฐฐ์ด ๋ด์์ ๋ฐ์ ์ ์๋๋ก 2์ฐจ์ ๋ฐฐ์ด์ ํ
๋๋ฆฌ๊น์ง ๋๋ํ๊ฒ ๋ง๋ค๊ณ , ์ฌ๊ธฐ์ ์
๋ ฅ๋ฐ์ ์ขํ๊ฐ๋ค์ ์ง์ด๋ฃ๋๋ค.
int [][] map = new int [row+2][col+2]
๊ทธ๋ฌ๋ฉด ์ด๋ ๊ฒ ๋ฐ์ ์ ์๋ค. ํ๋์์ผ๋ก ์น ํด์ง ๋ถ๋ถ์ ๋ณ๋ฐฉ ํ
๋๋ฆฌ๋ก ์ฐ๋ฆฌ๊ฐ ๋ฃ์ ๊ฒ์ด๋ค.
(2) ๊ฑด๋ฌผ์ด ์๋ ์ขํ๋ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ ํ๋ค.
์ฐ๋ฆฌ๋ ์ธ๋ฒฝ์ ์ซ์๋ง ์ธ๋ฉด ๋๋ค. ๋ด๊ฐ ๋งจ ์ฒ์์ ํ๋ ค๋ ํ์ด๊ฐ ๊ฑด๋ฌผ์ ๋ชจ๋ ๋ฒฝ์ ๊ตฌํด์ ๋ด๋ฒฝ์ ๋นผ๋ ค ํ๋๋ฐ, ๊ทธ ๋ฐฉ๋ฒ์ ๊ตฌํ์ด ์ฝ์ง๊ฐ ์์๋ค. ๊ทธ ๋์ (3)์ ๋ฐฉ๋ฒ์ ์์ํ๋ฉด ์ฝ๋ค.
(3) (0,0)์์ ์ก๋ฐฉํ์
BFS๋ฅผ ์์ํ๋ค. ํน์ ๋ฐฉํฅ์ ์ ์ ์ ํ์ํ๋๋ฐ ๊ทธ ์ ์ ์ด ๊ฑด๋ฌผ
์ด๋ผ๋ฉด, ์ธ๋ฒฝ ์นด์ดํธ๋ฅผ +1 ์ฌ๋ฆฐ๋ค. ์ ์ด๋ ๊ฒ ํ๋ฉด ๋ ๊น? ์ด์ ๋ ๋ค์๊ณผ ๊ฐ๋ค.
- (0,0)์์ ํ์์ ์์ํ๋ฉด, ๊ฑด๋ฌผ๋ก ๋๋ฌ์ธ์ฌ ๋ด๋ฒฝ์ด ๋ ๊ณณ์ ์ ๊ทผํ์ง ๋ชปํ๋ค.
- ๋ฐ๋ผ์ ๋ฐ๊นฅ์์ ๋ง๋๋ ๋ถ๋ถ์ ๋ชจ๋ ์ธ๋ฒฝ์ด ๋๋ค.
์ ๊น! ์ก๋ฐฉ ํ์์ ํ๋ ๋ฐฉ๋ฒ์??
ํด๋น ๋ฌธ์ ๋ ๊ทธ๋ํ ๋ฐฐ์น๊ฐ 6๊ฐํ ํํ๋ก ๋์ด์๋ค.
๋ฐ๋ผ์ BFS๋ก ๊ทธ๋ํ๋ฅผ ํ์ํ ๋๋, ์ก๋ฐฉ ํ์์ ํด์ผํ๋ค. ๋ฌธ์ ์์ ์ฃผ์ด์ง ์ฌ์ง์ ํต์์ ์ธ 2์ฐจ์ ๋ฐฐ์ด์ ํ๊ณผ ์ด์ ๋ฐ๋๋ก ์ ์ด๋์ ํท๊ฐ๋ฆด ์ ์๋ค. ์ก๊ฐํ ๊ทธ๋ํ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํํ๊ณ , ์ ์ค์์ ๊ฐ์ผ๋ก ์ธ์ ํ๋ ฌ๊ณผ์ ์ฐจ์ด๋ฅผ ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
์ก๊ฐํ ๊ทธ๋ํ๊ฐ ์ง์ํ๊ณผ ํ์ํ๋ง๋ค ์์น๊ฐ ๋ฌ๋ผ์, ๋์ ๋ฐ๋ก ๊ณ์ฐํด์ผํจ์ ์์ง ๋ง์.
์ด์ ์์์ ์ ๋ฆฌํ ์ ๊ทผ ๋ฐฉ์์ ํ ๋๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
public class Main {
static int [][] forEven = new int[][]{{-1,-1}, {-1,0}, {0,1}, {1,0}, {1,-1}, {0,-1}};
static int [][] forOdd = new int[][]{{-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {0,-1}};
static int paint = 0;
public static void main(String[] args) throws IOException {
// ์
๋ ฅ ๋ฐ๊ธฐ
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int col = Integer.parseInt(st.nextToken());
int row = Integer.parseInt(st.nextToken());
int [][] map = new int[row+2][col+2];
for (int i = 1; i <= row; i++) {
st = new StringTokenizer(br.readLine());
for (int j = 1; j <= col; j++) {
map[i][j] = Integer.parseInt(st.nextToken());
}
}
bfs(map, 0,0);
System.out.println(paint);
}
public static void bfs(int [][] map, int x, int y) {
// ๋ฏธ๋ฐฉ๋ฌธ ๊ธธ: 0, ๊ฑด๋ฌผ:1, ๋ฐฉ๋ฌธ ๊ธธ 2
ArrayDeque<Coordinate> aq1 = new ArrayDeque<>();
aq1.add(new Coordinate(x,y));
map[x][y] = 2;
while (!aq1.isEmpty()){
Coordinate now = aq1.poll();
int [][] direction = (now.row%2 == 0? forEven : forOdd);
int cnt = 0;
// ํ์ฌ ์์น์์ 6๋ฐฉ ๊ฒ์
for (int i = 0; i < direction.length; i++) {
int nRow = now.row + direction[i][0];
int nCol = now.col + direction[i][1];
if(nRow >= 0 && nRow < map.length && nCol >= 0 && nCol < map[0].length){
// ๊ฑด๋ฌผ์ด๋ฉด ์ธ๋ฒฝ์ ์น ํด์ผํจ์ผ๋ก cnt++;
if(map[nRow][nCol] == 1) cnt++;
// ๋ฏธ๋ฐฉ๋ฌธ ๊ธธ์ด๋ฉด ๋ฐฉ๋ฌธ ์ฒดํฌํ๊ณ queue์ ๋ฃ์!
else if (map[nRow][nCol] == 0) {
map[nRow][nCol] = 2;
aq1.add(new Coordinate(nRow,nCol));
}
}
}
paint += cnt;
}
}
}
class Coordinate {
int row;
int col;
public Coordinate(int row, int col){
this.row = row;
this.col = col;
}
}