56-tgyuyAn

[tgyuuAn]

🔗 문제 링크

공주님을 구해라!

✔️ 소요된 시간

40분

✨ 수도 코드

아래와 같은 성 정보가 주어졌을 때,

(1, 1) 에서 시작하여 (N, M) 에 있는 공주님을 구하면 되는 문제...!

이제 평상시에는 벽을 뚫지 못하는데,

성에 하나 있는 전설의 검 그람을 얻게 되면 모든 벽을 파괴하고 지나갈 수 있게 된다...!

근데 이제 공주님이 살아있을 제한 시간이 있어서 해당 제한 시간 안에 공주를 구할 수 있으면 최단 시간을 출력하고,

무슨 수를 써서라도 제한 시간 안에 구할 수 없으면 "Fail" 을 출력하면 되는 문제이다.

이 문제를 보자마자 2가지 경우로 나눠서 생각했다.

1. 전설의 검 그람을 얻어서 벽을 뚫었을 때 최단 시간

2. 검을 구하지 말고 정상적인 길로만 갔을 때의 최단 시간

즉, 검을 얻고 벽을 뚫고 갈 때의 최단 시간과 검을 얻지 않고 정상적인 길로만 갔을 때의 최단 시간을 각각 구한 뒤,

최종적인 최단 시간이 공주님이 살아있을 시간 보다 작으면 출력 아니면 Fail을 출력하면 되는 간단한 문제!

근데 이제 나는 일요일 아침의 데이트 문제와 비슷한 문제인 줄 알고,

힙을 써서 풀었지만 최종적인 코드는 결국 BFS 였다.

그냥 visited에서 왔던 길 다시 가지 않게 설정하고,

전설의 검 그람이 있는 위치에 도착했을 경우

검을 얻으러 갈 때 까지의 시간 + (M- 해당 위치 x 좌표) + (N - 해당 위치 y 좌표) 만 더하면 검을 얻었을 때의 최단 시간을 구할 수 있었기 때문이다.

위 까지 진행하면 골드 5문제에서 실버 수준의 일반적인 BFS 문제로 바뀌었다.

그럼...

아자아자뵤!

📚 새롭게 알게된 내용

[SeongHoonC]

우선순위 큐를 안쓰니깐 최소값을 계속 생각한다고 무수히 많은 반례를 만났네요..하하

import java.io.BufferedReader
import java.io.InputStreamReader
import kotlin.math.min

lateinit var castle: Array<Array<Int>>

private val dx_1 = listOf(0, 1, -1, 0)
private val dy_1 = listOf(1, 0, 0, -1)
const val INF = 987_654_321
var gramTime = INF
fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m, T) = br.readLine().split(" ").map { it.toInt() }
    castle = Array(n) { Array(m) { 0 } }

    for (i in 0 until n) {
        val line = br.readLine().split(" ").map { it.toInt() }
        line.forEachIndexed { index, value ->
            castle[i][index] = if (value == 0) INF else if (value == 2) -2 else value
        }
    }

    bfs(0 to 0, n, m, T)
    val result = min(gramTime, castle[n - 1][m - 1])
    println(if (result == INF || result > T) "Fail" else result)
}
// -2 검

fun bfs(start: Pair<Int, Int>, n: Int, m: Int, T: Int) {
    val q = ArrayDeque<Pair<Int, Int>>()
    q.add(start)
    castle[start.first][start.second] = 0

    while (q.isNotEmpty()) {
        val (x, y) = q.removeFirst()
        for (i in 0..3) {
            val nextX = x + dx_1[i]
            val nextY = y + dy_1[i]

            // 범위를 넘어감
            if (nextX < 0 || nextY < 0 || nextX >= n || nextY >= m) {
                continue
            }
            // 칼 주었을 때
            if (castle[nextX][nextY] == -2) {
                val distance = (n - 1) - nextX + (m - 1) - nextY
                val nowTime = castle[x][y] + 1
                gramTime = min(gramTime, nowTime + distance)
                continue
            }
            // 이미 방문했거나 벽
            if (castle[nextX][nextY] != INF) {
                continue
            }
            // 최소값 업데이트 && 큐에 넣기
            castle[nextX][nextY] = min(castle[nextX][nextY], castle[x][y] + 1)
            q.add(nextX to nextY)
        }
    }
}

[H0ngJu]

코드 다 짜고 보니까 그냥 태규님 코드랑 완전 같네용
heap이냐 deque냐 밖에 차이가 없는 것 같아요

재밌게 문제 풀고 갑니다 ~~ 수고하셨습니다 ~~~👍👍

import sys
from collections import deque

def input(): return sys.stdin.readline().rstrip()

N, M, T = map(int, input().split())
maze = [list(map(int, input().split())) for _ in range(N)]
visited = [[0 for _ in range(M)] for _ in range(N)]
direc = [(1,0),(-1,0),(0,1),(0,-1)]
time = 9999999

q = deque()
q.append((0, 0, 0))
visited[0][0] = 1

while q:
    cx, cy, c_time = q.popleft()

    if cx == N-1 and cy == M-1:
        time = min(c_time, time)
        break

    if maze[cx][cy] == 2:
        time = min(time, c_time + abs(N-1-cx) + abs(M-1-cy))

    for dx, dy in direc:
        nx = cx + dx
        ny = cy + dy
        if 0 <= nx < N and 0 <= ny < M and not visited[nx][ny] and maze[nx][ny] != 1:
            q.append((nx, ny, c_time + 1))
            visited[nx][ny] = 1

if time <= T:
    print(time)
else:
    print("Fail")

[H0ngJu]

오호? 이렇게 if문을 뒤에 써도 되네요 ㄷㄷ 하나 알아갑니다

[tgyuuAn]

@H0ngJu 막 그렇게 유용한 건 아닌데 삼항 연산자 느낌으로 쓸 수 있어요 키킼

[alstjr7437]

BFS 기본문제라서 쉽게 푼 것 같네요!!!

import sys
from collections import deque

input = sys.stdin.readline
n, m, t = map(int, input().split())
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]

graph = [list(map(int, input().split())) for _ in range(n)]
visited = [[0] * m for _ in range(n)] 

queue = deque()

def bfs():
    gram = 10001
    queue.append((0, 0))
    visited[0][0] = 1
    while queue:
        x, y = queue.popleft()
        if (x, y) == (n-1, m-1):  # 목적지 (n-1, m-1)
            return min(visited[x][y] - 1, gram)
        if graph[x][y] == 2:  # 검을 찾은 경우
            gram = visited[x][y] - 1 + (n-1-x) + (m-1-y)
        
        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny]:
                if graph[nx][ny] == 0 or graph[nx][ny] == 2:
                    visited[nx][ny] = visited[x][y] + 1
                    queue.append((nx, ny))
    return gram

res = bfs()

if res > t:
    print('Fail')
else:
    print(res)

[alstjr7437]

사실 처음에 풀어서 맞아놓고 Heap을 쓰시길래 다른 풀이 방법을 이해하려고 어....🧐 했습니다.
그런데 그냥 BFS로 풀면 풀리길래 heap으로도 풀 수 있겠구나 하고 넘어갔어요!!

[tgyuuAn]

@alstjr7437 의미없는 짓이었씁니다... ...