31-alstjr7437

[alstjr7437]

🔗 문제 링크

게임 맵 최단거리

✔️ 소요된 시간

20분(너무 쉬운 문제를 해버렸네요,, 하루 종일 코딩을 했더니 체력이 없어서 죄송합니다ㅠ,,)

✨ 수도 코드

문제를 보고 어,,, 너무 쉬운데,,? 그래서 파이썬으로 한 10분만에 풀고

너무 날먹인 것 같고,, Swift로도 가능할 것 같아서 Swift로도 짜봤습니다!!

따로 로직은 정말 간단한 BFS라 설명할 것 도 없는 수준입니다!!

그냥 시작칸부터 1로 시작해서 몇칸을 이동해서 도착점에 가는지 세는 알고리즘입니다!!

from collections import deque
def solution(maps):
    answer = 0

    dx = [-1, 1, 0, 0]
    dy = [0, 0, -1, 1]

    def bfs(x, y):
        queue = deque()
        queue.append((x, y))

        while queue:
            x, y = queue.popleft()

            for i in range(4):
                nx = x + dx[i]
                ny = y + dy[i]

                if nx < 0 or nx >= len(maps) or ny < 0 or ny >= len(maps[0]): continue

                if maps[nx][ny] == 0:  continue

                if maps[nx][ny] == 1:
                    maps[nx][ny] = maps[x][y] + 1
                    queue.append((nx, ny))

        return maps[len(maps)-1][len(maps[0])-1]

    answer = bfs(0, 0)
    return -1 if answer == 1 else answer    

import Foundation

func solution(_ maps: inout [[Int]]) -> Int {
    let dx = [-1, 1, 0, 0]
    let dy = [0, 0, -1, 1]
    let rowCount = maps.count
    let colCount = maps[0].count
    
    func bfs(_ x: Int, _ y: Int) -> Int {
        var queue = [(x, y)]
        var index = 0
        
        while index < queue.count {
            let (x, y) = queue[index]
            index += 1
            
            for i in 0..<4 {
                let nx = x + dx[i]
                let ny = y + dy[i]
                
                if nx < 0 || nx >= rowCount || ny < 0 || ny >= colCount { continue }
                
                if maps[nx][ny] == 0 { continue }
                
                if maps[nx][ny] == 1 {
                    maps[nx][ny] = maps[x][y] + 1
                    queue.append((nx, ny))
                }
            }
        }
        
        return maps[rowCount - 1][colCount - 1]
    }
    
    let answer = bfs(0, 0)
    return answer == 1 ? -1 : answer
}

// 예시 호출
var maps = [
    [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] 
]
print(solution(&maps)) // 출력: 11

📚 새롭게 알게된 내용

이번에 네부캠 첫날을 하면서 inout Parameters에 대해 배우게 되서 노션에 정리했습니다.(네부캠 제출용도 있고,,,,)

[tgyuuAn]

from collections import deque

def solution(maps):    
    dx = [0, 0, -1, 1]
    dy = [-1, 1, 0, 0]
    
    visited = {(0,0),}
    deq = deque()
    deq.append((0,0,1))
    while deq:
        now_x, now_y, now_count = deq.popleft()
        
        if (now_x, now_y) == (len(maps[0])-1, len(maps)-1):
            return now_count
        
        for dir in range(4):
            new_x = now_x + dx[dir]
            new_y = now_y + dy[dir]
            
            if new_x < 0 or new_x >= len(maps[0]): continue
            if new_y < 0 or new_y >= len(maps): continue
            if (new_x, new_y) in visited: continue
            if maps[new_y][new_x] == 0: continue
            
            visited.add((new_x, new_y))
            deq.append((new_x, new_y, now_count+1))
        
    return -1

짜잔!!!
아니 이거 그냥 BFS DFS인데?!

[tgyuuAn]

이건 파이썬 코드가 아닌데 확장자가 파이썬이네?!

[SeongHoonC]

자바로 코테 연습하는데 귀찮은게 많네요..
저도 그냥 BFS 로 풀었숨당

import java.util.*;
import java.awt.*;

class Solution {
    
    int[] dx = { 0,0,1,-1};
    int[] dy = { 1,-1,0,0};
    
    public int solution(int[][] maps) {
        int answer = 0;
        ArrayDeque<Point> q = new ArrayDeque<Point>();
        var n = maps.length;
        var m = maps[0].length;
        
        q.add(new Point(0,0));
        while(!q.isEmpty()){
            Point now = q.removeFirst();    
            
            for(int i = 0; i < 4; i++) {
                int nextX = now.x + dx[i];
                int nextY = now.y + dy[i];
                
                if(nextX >= n || nextX < 0 || nextY >= m || nextY <0) {
                    continue;
                } 
                
                if(maps[nextX][nextY] != 1) {
                    continue;
                }
                
                if(nextX == n - 1 && nextY == m - 1) {
                    return maps[now.x][now.y] + 1;
                }
                maps[nextX][nextY] = maps[now.x][now.y] + 1;
                q.add(new Point(nextX, nextY));
                
            }
        }
        return -1;
    }
}