๐ ๋ฌธ์
https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5PpLlKAQ4DFAUq&
๊ต๋์๋ก ์ด์ก ์ค์ด๋ ํ์
๋ฒ์ด ํ์ถํ๋ ์ฌ๊ฑด์ด ๋ฐ์ํ์ฌ ์์์ ๋์ฐ๋ค.
ํ์ฃผ๋ฒ์ ํ์ถํ ์ง ํ ์๊ฐ ๋ค, ๋งจํ ๋๊ป์ ํตํด ์งํํฐ๋์ ์ด๋ ํ ์ง์ ์ผ๋ก ๋ค์ด๊ฐ์ผ๋ฉฐ,
์งํ ํฐ๋ ์ด๋๊ฐ์์ ์์ ์ค์ธ ๊ฒ์ผ๋ก ์ถ์ ๋๋ค.
ํฐ๋๋ผ๋ฆฌ ์ฐ๊ฒฐ์ด ๋์ด ์๋ ๊ฒฝ์ฐ ์ด๋์ด ๊ฐ๋ฅํ๋ฏ๋ก ํ์ฃผ๋ฒ์ด ์์ ์ ์๋ ์์น์ ๊ฐ์๋ฅผ ๊ณ์ฐํ์ฌ์ผ ํ๋ค.
ํ์ฃผ๋ฒ์ ์๊ฐ๋น 1์ ๊ฑฐ๋ฆฌ๋ฅผ ์์ง์ผ ์ ์๋ค.
์งํ ํฐ๋์ ์ด 7 ์ข
๋ฅ์ ํฐ๋ ๊ตฌ์กฐ๋ฌผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ ๊ฐ ๊ตฌ์กฐ๋ฌผ ๋ณ ์ค๋ช
์ [ํ 1]๊ณผ ๊ฐ๋ค.
[๊ทธ๋ฆผ 1-1] ์ ์งํ ํฐ๋ ์ง๋์ ํ ์๋ฅผ ๋ํ๋ธ๋ค.
์ด ๊ฒฝ์ฐ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ๋ 5, ๊ฐ๋ก ํฌ๊ธฐ๋ 6 ์ด๋ค.
๋งจํ ๋๊ป์ ์์น๊ฐ ( 2, 1 ) ์ผ๋ก ์ฃผ์ด์ง ๊ฒฝ์ฐ, ์ด๋ ์ธ๋ก ์์น 2, ๊ฐ๋ก ์์น 1์ ์๋ฏธํ๋ฉฐ [๊ทธ๋ฆผ 1-2] ์์ ๋ถ์ ์์ผ๋ก ํ๊ธฐ๋ ๊ตฌ์ญ์ด๋ค.
ํ์ฃผ๋ฒ์ด ํ์ถ ํ ์๊ฐ ๋ค ๋๋ฌํ ์ ์๋ ์ง์ ์ ํ ๊ณณ์ด๋ค.
ํ์ฃผ๋ฒ์ด 2์๊ฐ ํ ๋๋ฌํ ์ ์๋ ์ง์ ์, [๊ทธ๋ฆผ 1-3] ๊ณผ ๊ฐ์ด ๋งจํ ๋๊ป์ด ์์นํ ๋ถ์ ์์ผ๋ก ํ์๋ ์งํ๋ ์ ํ๋์์ผ๋ก ํ๊ธฐ๋ ์งํ๋๊น์ง ์ด 3๊ฐ์ ์ฅ์์ ์์ ์ ์๋ค.
3์๊ฐ ํ์๋ [๊ทธ๋ฆผ 1-4] ๊ณผ ๊ฐ์ด ์ด 5๊ฐ์ ์ง์ ์ ์์ ์ ์๋ค.
[๊ทธ๋ฆผ 2-1] ์์ ๋งจํ๋๊ป์ด ์์นํ ์ง์ ์ด ( 2, 2 ) ์ด๊ณ ๊ฒฝ๊ณผํ ์๊ฐ์ด 6 ์ผ๋ก ์ฃผ์ด์ง ๊ฒฝ์ฐ,
[๊ทธ๋ฆผ 2-2] ์์ ๋งจํ๋๊ป์ด ์์นํ ์ง์ ์ ๋ถ์ ์, ํ์ฃผ๋ฒ์ด ์์ ์ ์๋ ์ฅ์๊ฐ ํธ๋ฅธ์์ผ๋ก ํ๊ธฐ๋์ด ์๋ค.
ํ์ฃผ๋ฒ์ด ์์ ์ ์๋ ์ฅ์๋, ๋งจํ๋๊ป์ด ์์นํ ์ง์ ์ ํฌํจํ์ฌ ์ด 15 ๊ฐ ์ด๋ค.
์งํ ํฐ๋ ์ง๋์ ๋งจํ ๋๊ป์ ์์น, ๊ฒฝ๊ณผ๋ ์๊ฐ์ด ์ฃผ์ด์ง ๋ ํ์ฃผ๋ฒ์ด ์์นํ ์ ์๋ ์ฅ์์ ๊ฐ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
[์ ์ฝ ์ฌํญ]
1. ์๊ฐ ์ ํ : ์ต๋ 50๊ฐ ํ
์ดํธ ์ผ์ด์ค๋ฅผ ๋ชจ๋ ํต๊ณผํ๋๋ฐ, C/C++/Java ๋ชจ๋ 1์ด
2. ์งํ ํฐ๋ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N, ๊ฐ๋ก ํฌ๊ธฐ M์ ๊ฐ๊ฐ 5 ์ด์ 50 ์ดํ์ด๋ค. (5 ≤ N, M ≤ 50)
3. ๋งจํ ๋๊ป์ ์ธ๋ก ์์น R ์ 0 ์ด์ N-1์ดํ์ด๊ณ ๊ฐ๋ก ์์น C ๋ 0 ์ด์ M-1์ดํ์ด๋ค. (0 ≤ R ≤ N-1, 0 ≤ C ≤ M-1)
4. ํ์ถ ํ ์์๋ ์๊ฐ L์ 1 ์ด์ 20 ์ดํ์ด๋ค. (1 ≤ L ≤ 20)
5. ์งํ ํฐ๋ ์ง๋์๋ ๋ฐ๋์ 1๊ฐ ์ด์์ ํฐ๋์ด ์์์ด ๋ณด์ฅ๋๋ค.
6. ๋งจํ ๋๊ป์ ํญ์ ํฐ๋์ด ์๋ ์์น์ ์กด์ฌํ๋ค.
[์
๋ ฅ]
์ฒซ ์ค์ ์ด ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค๋ถํฐ T๊ฐ์ ํ
์คํธ ์ผ์ด์ค๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค์ ์ฒซ ์ค์๋ ์งํ ํฐ๋ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N, ๊ฐ๋ก ํฌ๊ธฐ M, ๋งจํ ๋๊ป์ด ์์นํ์ฅ์์ ์ธ๋ก ์์น R, ๊ฐ๋ก ์์น C, ๊ทธ๋ฆฌ๊ณ ํ์ถ ํ ์์๋ ์๊ฐ L ์ด ์ฃผ์ด์ง๋ค.
๊ทธ ๋ค์ N ์ค์๋ ์งํ ํฐ๋ ์ง๋ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋๋ฐ, ๊ฐ ์ค๋ง๋ค M ๊ฐ์ ์ซ์๊ฐ ์ฃผ์ด์ง๋ค.
์ซ์ 1 ~ 7์ ํด๋น ์์น์ ํฐ๋ ๊ตฌ์กฐ๋ฌผ ํ์
์ ์๋ฏธํ๋ฉฐ ์ซ์ 0 ์ ํฐ๋์ด ์๋ ์ฅ์๋ฅผ ์๋ฏธํ๋ค.
[์ถ๋ ฅ]
ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์๋งํผ T์ค์ T๊ฐ์ ํ
์คํธ ์ผ์ด์ค ๊ฐ๊ฐ์ ๋ํ ๋ต์ ์ถ๋ ฅํ๋ค.
๊ฐ ์ค์ “#x”๋ก ์์ํ๊ณ ๊ณต๋ฐฑ์ ํ๋ ๋ ๋ค์ ์ ๋ต์ ๊ธฐ๋กํ๋ค. (x๋ 1๋ถํฐ ์์ํ๋ ํ
์คํธ ์ผ์ด์ค์ ๋ฒํธ์ด๋ค)
์ถ๋ ฅํด์ผ ํ ์ ๋ต์ ํ์ฃผ๋ฒ์ด ์์นํ ์ ์๋ ์ฅ์์ ๊ฐ์์ด๋ค.
โ๏ธ ํ์ด
โ๏ธ ํ์ดํ ๋ฒํธ๋ง๋ค ์ด๋ํ ์ ์๋ ๋ชจ๋ ๋ฐฉํฅ์ ํ์ํ๋ค.
์ด๋ ํ์๋๋ ๊ฐ x๋ ํ์ฌ ์์น์์ r+dr[x], c+dc[x]๋ฅผ ํ์ํ ๋์ ๋ฐฉํฅ ๊ฐ์ด๋ค.
์) dr={1, -1, 0, 0} / dc={0,0,1,-1} >> ์ํ์ฐ์ข
๋ฐฉํฅ ๊ฐ์ด 0์ด๋ผ๋ฉด r+dr[0], c+dc[0]์ ํตํด ์์ชฝ์ผ๋ก ์ด๋ํ๊ฒ ๋๋ค.
๋ฐฉํฅ ๊ฐ์ด 3์ด๋ผ๋ฉด r+dr[3], c+dc[3]์ด ๋๋ฉด์ ์ข์ธก์ผ๋ก ์ด๋ํ๋ค.
์ฆ, ํ์ดํ ๋ฒํธ๊ฐ 2์ด๊ณ ๊ทธ๋ ์ด๋ํ ์ ์๋ ๋ฐฉํฅ ๊ฐ์ด 0, 1๋ก ์ฃผ์ด์ง๋ค๋ฉด,
์ด ํ์ดํ๋ ์๋(0)/์(1)๋ก ์ด๋ํ ์ ์๋ค๋ ๋ป์ด ๋๋ค.
๋๋ ์๋์ฒ๋ผ ํ์ํ๋ค. ๋ฐฉํฅ ๊ฐ์ด -1์ธ ๊ฒ์ ์ด๋ํ ์ ์๋ ๊ณณ์ด๋ ๋ป์ด๋ค.
static int[][] tunnel = { // ํ์ดํ ๋ฒํธ
{-1}, // 0 ์๋ ๋ฒํธ
{0,1,2,3}, // 1
{0,1}, // 2
{2,3}, // 3
{1,2}, // 4
{0,2}, // 5
{0,3}, // 6
{1,3} // 7
};
๋ค์ ํ ๋ฒ ์ค๋ช ํด๋ณด๊ฒ ๋ค.
5๋ฒ ํ์ดํ๊ฐ ์๋ค๊ณ ํด๋ณด์. ์ด ํ์ดํ๋ฅผ ๋ง๋ฌ์ ๋ ์ด๋ํ ์ ์๋ ๋ฐฉํฅ์ ๋ณด๋ ค๋ฉด tunnel ๋ณ์์ 5๋ฒ ๋ฐฐ์ด์ ๋ณด๋ฉด ๋๋ค.
๊ทธ๋ฆผ์์ ๋ณผ ์ ์๋ฏ์ด, ํ์ฌ 5๋ฒ ํ์ดํ ์์ ์๋ค๊ณ ํ๋ค๋ฉด ์ด๋ํ ์ ์๋ ๋ฐฉํฅ์ ์๋์ชฝ(0), ์ค๋ฅธ์ชฝ(2) ๋ ๊ฐ์ง๋ฐ์ ์๋ค.
๋ฐ๋ผ์ tunnel[5]์ ๊ฐ์ผ๋ก๋ 0,2๊ฐ ๋ค์ด๊ฐ๊ฒ ๋๋ค.
โ๏ธ ํ์ฌ ์์น์์ ์ฌ๋ฐฉ์ ํ์ธ, ์๋ก ์ด๋ํ ์ ์๋ ์์น๋ฅผ ๋๊ธฐํ์ ๋ฃ๋๋ค.
์ด๋ฏธ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ ์์น๋ผ๋ฉด ๋ค์ ๋ณด์ง ์๋๋ค.
โ๏ธ ์ด๋ํ ์ ์๋ ์์น๋ผ๋ ํ์ฌ ์์น์ ์ด์ด์ ธ ์๋์ง๋ฅผ ํ์ธํด์ผํ๋ค.
ํ๋ณด ์์น์์ ๋ฐฉ๋ฌธํ ์ ์๋ ์์น๋ฅผ ํ์ธํ์ ๋ ํ์ฌ ์์น๊ฐ ์๋ค๋ฉด, ํ๋ณด ์์น๋ก ์ด๋ํ ์ ์๋ค. (ํ์ ๋ฃ์ ์ ์๋ค)
์์๋ก๋ ๋ค์๊ณผ ๊ฐ์ ์ฌ์ง์ ๋ค ์ ์๋ค.
์๋ ํ์ดํ์์๋ ์์ชฝ์ผ๋ก ์ด๋ํ ์ ์์ง๋ง, ์์ชฝ ํ์ดํ๊ฐ ์๋ ํ์ดํ์ ์ฐ๊ฒฐ๋์ด์์ง ์์ผ๋ฏ๋ก ์ด๋ํ ์ ์๋ ์กฐ๊ฑด์ด ์๋๋ค. ์ด๋ฌํ ์กฐ๊ฑด์ ์๊ฐํด์ฃผ์ด์ผ ํ๋ค.
โ๏ธ ํ์ ๊ฐ์ ๋ฃ์ ๋๋ ์์น๊ฐ๊ณผ ํจ๊ป ์๊ฐ๋ 1์ ๋ํด ๋ฃ์ด์ค๋ค.
ํ์์ ์๋ก ๋ฝ์ ํ์ฌ ์์น๊ฐ ์์์๊ฐ L์ผ ๋์๋ ๋ค์ ์์น๋ฅผ ์ดํด๋ณผ ํ์๊ฐ ์๋ค.
๐โ๏ธ ์๊ฒฌ
์์งํ ๋ด๊ฐ ์ง ์ฝ๋๊ฐ ์ต์ ์ ์ฝ๋์ธ์ง๋ ๋ชจ๋ฅด๊ฒ ๋ค (ใ ใ )
๊ต์๋์ด ๋ฐ๋ก ํ์ด๋ฅผ ํด์ฃผ์ จ๋๋ฐ, ํํ ๋ฑ ๊ทธ๋ ํ์๋ต์ง ์๊ฒ ์กธ์๋ฒ๋ ค์.....์ฝ๋๊ฐ ์๋ค.
๋ค์ ์ ๋ฆฌํ๋ ค๊ณ ๋ณด๋๊น ์ธํผ๋ฅผ ํด์ํด์ ์ฝ๋๋ฅผ ๋ณผ ์๊ฐ ์๋ค.
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
public class Solution_SWEA_1953_ํ์ฃผ๋ฒ๊ฒ๊ฑฐ_๋์ธ์ด {
static int[] dr = {1,-1,0,0};
static int[] dc = {0,0,1,-1};
static int[][] tunnel = {
{-1}, // 0
{0,1,2,3}, // 1
{0,1}, // 2
{2,3}, // 3
{1,2}, // 4
{0,2}, // 5
{0,3}, // 6
{1,3} // 7
};
static int[][] map;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int TC = Integer.parseInt(br.readLine().trim());
for (int testCase = 1; testCase <= TC; testCase++) {
StringTokenizer st = new StringTokenizer(br.readLine().trim());
int N = Integer.parseInt(st.nextToken()); //์ธ๋ก
int M = Integer.parseInt(st.nextToken()); //๊ฐ๋ก
int R = Integer.parseInt(st.nextToken()); //๋งจํR
int C = Integer.parseInt(st.nextToken()); //๋งจํC
int L = Integer.parseInt(st.nextToken()); //์์์๊ฐ
map = new int[N][M];
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine().trim());
for (int j = 0; j < M; j++) {
map[i][j] = Integer.parseInt(st.nextToken());
}
}//input
int result = 0;
boolean[][] visited = new boolean[N][M];
Queue<int[]> queue = new LinkedList<int[]>();
queue.offer(new int[] {R,C, 1}); // r, c, time
visited[R][C]=true;
result++;
while(queue.size()>0) {
int[] cur = queue.poll();
int r = cur[0];
int c = cur[1];
int t = cur[2];
int p = map[r][c];//ํ์ฌ ์์น์ ํ์ดํ ๋ฒํธ
//์์์๊ฐ์ด ๋ค ๋์ผ๋ฉด ๋ ์์ง์ด์ง ์๋๋ค.
if(t==L) continue;
// ํ์ฌ ์์น์ ํ์ดํ์์ ์ด๋ํ ์ ์๋ ๋ชจ๋ ๋ฐฉํฅ์ ํ์
for (int i = 0; i < tunnel[p].length; i++) {
int nd = tunnel[p][i];
int nr = r + dr[nd];
int nc = c + dc[nd];
if(nr<0||nc<0||nr>=N||nc>=M||
map[nr][nc]==0 ||
visited[nr][nc]) continue;
// ์ ํ์ดํ๊ฐ ํ์ฌ ์์น์ ์ฐ๊ฒฐ๋์ด์์ง ์๋ค๋ฉด ํจ์ค
if(!isConnected(r,c,nr,nc)) continue;
// ํ์ํ ์์น๋ก ์ด๋
visited[nr][nc]=true;
queue.offer(new int[] {nr,nc, t+1});
result++;
}
}//
sb.append("#").append(testCase).append(" ").append(result).append("\n");
}//end of testCase
System.out.println(sb);
}//end of main
private static boolean isConnected(int r1, int c1, int r2, int c2) {
int p = map[r2][c2]; //์ ํ์ดํ ๋ฒํธ
for (int i = 0; i < tunnel[p].length; i++) {//์ ํ์ดํ์์ ์ด๋ํ ์ ์๋ ๋ชจ๋ ๋ฐฉํฅ
int nd = tunnel[p][i];
//ํ์ฌ ๋ฐฉํฅ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๋ฉด
if(r2+dr[nd]==r1 && c2+dc[nd]==c1) {
return true;
}
}
return false;
}//end of isConnected
}//end of class
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ
'์๊ณ ๋ฆฌ์ฆ > SWEA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[SWEA] 5215 ํ๋ฒ๊ฑฐ ๋ค์ด์ดํธ D3 - ์๋ฐ(Java)/ ์ค๋ณต์กฐํฉ, DFS, DP (3) | 2023.12.03 |
---|