[Python - ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค Level4] ๊ฒŒ์ž„ ๋งต ์ตœ๋‹จ ๊ฑฐ๋ฆฌ

2021. 1. 21. 22:18ใ†๐Ÿ“š Algorithm/๐Ÿ’ช๐Ÿป Python ๋ฌธ์ œ ํ’€์ด

๋ฐ˜์‘ํ˜•
 

์ฝ”๋”ฉํ…Œ์ŠคํŠธ ์—ฐ์Šต - ๊ฒŒ์ž„ ๋งต ์ตœ๋‹จ๊ฑฐ๋ฆฌ

[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]] 11 [[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]] -1

programmers.co.kr

๋ฌธ์ œ ์„ค๋ช…

ROR ๊ฒŒ์ž„์€ ๋‘ ํŒ€์œผ๋กœ ๋‚˜๋ˆ„์–ด์„œ ์ง„ํ–‰ํ•˜๋ฉฐ, ์ƒ๋Œ€ ํŒ€ ์ง„์˜์„ ๋จผ์ € ํŒŒ๊ดดํ•˜๋ฉด ์ด๊ธฐ๋Š” ๊ฒŒ์ž„์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ, ๊ฐ ํŒ€์€ ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ์ตœ๋Œ€ํ•œ ๋นจ๋ฆฌ ๋„์ฐฉํ•˜๋Š” ๊ฒƒ์ด ์œ ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.

์ง€๊ธˆ๋ถ€ํ„ฐ ๋‹น์‹ ์€ ํ•œ ํŒ€์˜ ํŒ€์›์ด ๋˜์–ด ๊ฒŒ์ž„์„ ์ง„ํ–‰ํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ์€ 5 x 5 ํฌ๊ธฐ์˜ ๋งต์—, ๋‹น์‹ ์˜ ์บ๋ฆญํ„ฐ๊ฐ€ (ํ–‰: 1, ์—ด: 1) ์œ„์น˜์— ์žˆ๊ณ , ์ƒ๋Œ€ ํŒ€ ์ง„์˜์€ (ํ–‰: 5, ์—ด: 5) ์œ„์น˜์— ์žˆ๋Š” ๊ฒฝ์šฐ์˜ ์˜ˆ์‹œ์ž…๋‹ˆ๋‹ค.

์œ„ ๊ทธ๋ฆผ์—์„œ ๊ฒ€์€์ƒ‰ ๋ถ€๋ถ„์€ ๋ฒฝ์œผ๋กœ ๋ง‰ํ˜€์žˆ์–ด ๊ฐˆ ์ˆ˜ ์—†๋Š” ๊ธธ์ด๋ฉฐ, ํฐ์ƒ‰ ๋ถ€๋ถ„์€ ๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๊ธธ์ž…๋‹ˆ๋‹ค. ์บ๋ฆญํ„ฐ๊ฐ€ ์›€์ง์ผ ๋•Œ๋Š” ๋™, ์„œ, ๋‚จ, ๋ถ ๋ฐฉํ–ฅ์œผ๋กœ ํ•œ ์นธ์”ฉ ์ด๋™ํ•˜๋ฉฐ, ๊ฒŒ์ž„ ๋งต์„ ๋ฒ—์–ด๋‚œ ๊ธธ์€ ๊ฐˆ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.
์•„๋ž˜ ์˜ˆ์‹œ๋Š” ์บ๋ฆญํ„ฐ๊ฐ€ ์ƒ๋Œ€ ํŒ€ ์ง„์˜์œผ๋กœ ๊ฐ€๋Š” ๋‘ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์„ ๋‚˜ํƒ€๋‚ด๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.

  • ์ฒซ ๋ฒˆ์งธ ๋ฐฉ๋ฒ•์€ 11๊ฐœ์˜ ์นธ์„ ์ง€๋‚˜์„œ ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ๋„์ฐฉํ–ˆ์Šต๋‹ˆ๋‹ค.

  • ๋‘ ๋ฒˆ์งธ ๋ฐฉ๋ฒ•์€ 15๊ฐœ์˜ ์นธ์„ ์ง€๋‚˜์„œ ์ƒ๋Œ€ํŒ€ ์ง„์˜์— ๋„์ฐฉํ–ˆ์Šต๋‹ˆ๋‹ค.

์œ„ ์˜ˆ์‹œ์—์„œ๋Š” ์ฒซ ๋ฒˆ์งธ ๋ฐฉ๋ฒ•๋ณด๋‹ค ๋” ๋น ๋ฅด๊ฒŒ ์ƒ๋Œ€ํŒ€ ์ง„์˜์— ๋„์ฐฉํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ์—†์œผ๋ฏ€๋กœ, ์ด ๋ฐฉ๋ฒ•์ด ์ƒ๋Œ€ ํŒ€ ์ง„์˜์œผ๋กœ ๊ฐ€๋Š” ๊ฐ€์žฅ ๋น ๋ฅธ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

๋งŒ์•ฝ, ์ƒ๋Œ€ ํŒ€์ด ์ž์‹ ์˜ ํŒ€ ์ง„์˜ ์ฃผ์œ„์— ๋ฒฝ์„ ์„ธ์›Œ๋‘์—ˆ๋‹ค๋ฉด ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ๋„์ฐฉํ•˜์ง€ ๋ชปํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๊ฒฝ์šฐ์— ๋‹น์‹ ์˜ ์บ๋ฆญํ„ฐ๋Š” ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ๋„์ฐฉํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๊ฒŒ์ž„ ๋งต์˜ ์ƒํƒœ maps๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ์บ๋ฆญํ„ฐ๊ฐ€ ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ๋„์ฐฉํ•˜๊ธฐ ์œ„ํ•ด์„œ ์ง€๋‚˜๊ฐ€์•ผ ํ•˜๋Š” ์นธ์˜ ๊ฐœ์ˆ˜์˜ ์ตœ์†Ÿ๊ฐ’์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”. ๋‹จ, ์ƒ๋Œ€ ํŒ€ ์ง„์˜์— ๋„์ฐฉํ•  ์ˆ˜ ์—†์„ ๋•Œ๋Š” -1์„ return ํ•ด์ฃผ์„ธ์š”.

์ œํ•œ ์‚ฌํ•ญ

  • maps๋Š” n x m ํฌ๊ธฐ์˜ ๊ฒŒ์ž„ ๋งต์˜ ์ƒํƒœ๊ฐ€ ๋“ค์–ด์žˆ๋Š” 2์ฐจ์› ๋ฐฐ์—ด๋กœ, n๊ณผ m์€ ๊ฐ๊ฐ 1 ์ด์ƒ 100 ์ดํ•˜์˜ ์ž์—ฐ์ˆ˜์ž…๋‹ˆ๋‹ค.
    • n๊ณผ m์€ ์„œ๋กœ ๊ฐ™์„ ์ˆ˜๋„, ๋‹ค๋ฅผ ์ˆ˜๋„ ์žˆ์ง€๋งŒ, n๊ณผ m์ด ๋ชจ๋‘ 1์ธ ๊ฒฝ์šฐ๋Š” ์ž…๋ ฅ์œผ๋กœ ์ฃผ์–ด์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
  • maps๋Š” 0๊ณผ 1๋กœ๋งŒ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, 0์€ ๋ฒฝ์ด ์žˆ๋Š” ์ž๋ฆฌ, 1์€ ๋ฒฝ์ด ์—†๋Š” ์ž๋ฆฌ๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.
  • ์ฒ˜์Œ์— ์บ๋ฆญํ„ฐ๋Š” ๊ฒŒ์ž„ ๋งต์˜ ์ขŒ์ธก ์ƒ๋‹จ์ธ (1, 1) ์œ„์น˜์— ์žˆ์œผ๋ฉฐ, ์ƒ๋Œ€๋ฐฉ ์ง„์˜์€ ๊ฒŒ์ž„ ๋งต์˜ ์šฐ์ธก ํ•˜๋‹จ์ธ (n, m) ์œ„์น˜์— ์žˆ์Šต๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ์‹œ

ํ’€์ด ๊ณผ์ •

0,0 ๋ถ€ํ„ฐ row-1, col -1 ๊นŒ์ง€ ๊ฐˆ์ˆ˜์žˆ๋Š” ์ตœ๋‹จ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ•˜๋Š” ๋ฌธ์ œ์ด๋ฏ€๋กœ bfs ๋ฅผ ์ด์šฉํ•˜์—ฌ ๋ฌธ์ œ๋ฅผ ํ’€์—ˆ์Šต๋‹ˆ๋‹ค.

queue์— 0,0 ๋ถ€ํ„ฐ ์›์†Œ๋ฅผ ๋„ฃ์–ด ๊ฒ€์‚ฌํ•˜๋Š” ๋ฐ ์ƒํ•˜์ขŒ์šฐ ์ด๋™ํ•œ new_x์™€ new_y ์˜ ์ขŒํ‘œ๊ฐ€ 0๊ณผ ROW, COL ์‚ฌ์ด์— ์žˆ๋Š”์ง€ ํ™•์ธํ•˜๋ฉฐ 

maps[ new_x ] [ new_y ]๊ฐ€ 1์ธ ๊ฒƒ๋งŒ queue์— ๋„ฃ์–ด์ฃผ๊ณ  count๋ฅผ +1 ํ•ด์ฃผ๋Š” ํ˜•์‹์œผ๋กœ while๋ฌธ์„ ๊ตฌํ˜„ํ•˜์˜€๊ณ 

๋งŒ์•ฝ queue๋ฅผ ๋ชจ๋‘ ์ฒดํฌํ•˜์˜€์ง€๋งŒ ROW-1, COL-1์„ ์ง€๋‚˜์ง€ ์•Š๋Š”๋‹ค๋ฉด ์ง„์˜์— ๊ฐˆ ์ˆ˜ ์—†๋Š” ๊ฒƒ์ด๋ฏ€๋กœ return -1 ํ•ด์ฃผ๋„๋ก ๋ฌธ์ œ๋ฅผ ํ’€์—ˆ์Šต๋‹ˆ๋‹ค.

from collections import deque
def solution(maps):
    answer = 0
    ROW = len(maps)
    COL = len(maps[0])
    check_maps = [[False for _ in range(COL)] for _ in range(ROW)]

    def available(x, y):
        return 0 <= x < ROW and 0 <= y < COL

    def bfs(x,y):
        count = 1
        dxy = [(-1, 0), (1, 0), (0, 1), (0, -1)]
        queue = deque([[x,y,count]])
        check_maps[x][y] = True
        while queue:
            x, y, count = queue.popleft()
            if x == ROW -1 and y == COL -1 :
                return count
            for dx, dy in dxy:
                new_x , new_y = x + dx , y + dy
                if available(new_x,new_y) and not check_maps[new_x][new_y]:
                    if maps[new_x][new_y] == 1:
                        queue.append([new_x, new_y , count+1])
                        check_maps[new_x][new_y] = True
        return -1

    return bfs(0,0)

 

 

 

๋ฐ˜์‘ํ˜•