4-YooGyeongMo

[YooGyeongMo]

🔗 문제 링크

로봇 청소기

언제 로봇 청소기삽니까 진짜... 하..

✔️ 소요된 시간

40분 + @

✨ 수도 코드

문제와 말 장난을 이해하는데 꽤나 시간이 걸렸습니다.

물론 문제를 딱 마주하자마자 이건 DFS/BFS면 손쉽게 풀리겠구나! 라고 생각하실겁니다.

저는 DFS를 선택했는데요 ! 그 이유는 ! 문제가 대놓고 Depth가 있어요. 해당 조건들을 나열하고 조건이 안될시에 다시 나오고. 이게 재귀로 풀면 좀 더 직관적이지 않을까? 해서 선택했습니다.

줄줄 적어본 것인데요.
먼저 로봇 쉑은 ㅋ 진짜 간단합니다. 저희 일반 로봇 청소기 로직 생각하면돼요.

앞으로 가다가, 장애물이 있으면 방향을 돌고, 청소할 데 없으면 뒤로 가고,
딱 그 수준입니다. 복잡할 게 없어요.
근데 문제는… 그걸 말로 설명하니까 엄청 어렵게 느껴진다는 거죠.
(왼쪽으로 돈다 → 그 방향에 청소할 공간이 있으면 전진 → 그게 없다면 다시 왼쪽… 이걸 네 번 반복… 어휴 😵‍💫)

말로는 괴랄했지만, 로직 자체는 우리가 집에서 보던 그 로봇 청소기 그대로였고, 그래서 저는 DFS로 한 칸 한 칸 따라가며 재귀로 구현했습니다.

// 왼쪽90도는 오른쪽으로 +3
func turnLeft(from direction: Int) -> Int {
    return (direction + 3) % 4
}

문제 순서에서는 뒷쪽에 나왔지만, 문제 조건들을 거꾸로 본다면 북동남서 방향을 청소 안한 곳을 왼쪽부터 체크하면 됩니다.

그래서 저는 +3을 해주었고 % 4 -> 이 로직은 시뮬레이션, 구현에서 상하좌우 비교시 꼭 나오니 외우시면 좋습니다.

그 다음, dfs는 거의 구조적으로 달라질 것은 없었어요.

1. 현재 위치 청소

2. 왼쪽 방향부터 4방향 탐색
   • 청소 안 된 칸 있으면 → 회전 → 전진 → 재귀 호출
   • 없으면 → 4방 모두 돌았다는 의미 → 후진

3. 후진 처리
   • 뒤쪽이 벽이라면 종료 (exit(0) 사용)
   • 아니라면 같은 방향으로 뒤로 한 칸 이동해 다시 dfs

Tip. 여기서 핵심은 제가 꽤나 고생한건데,,, 가로 세로 개념이 좌표계에선 반대가 된다는 것입니다.

x 는 가로, y가 세로잖아요.

column이 가로로 커져야하고, row가 세로로 커져야해요.

그래서 board[y][x]로 [r][c] 순으로 해줘야합니다.

또한 =2 처럼 꼭 2가 아니더라도 내가 청소했다라는 경계값 선정도 중요할듯합니다.

아래와 같이 일관성 있게 처리해줘야합니다.

0 -> 청소하지않은칸
1 -> 벽
2 -> 청소한칸

문제에서의 조건 인덱싱은 속지말아야합니다.

첫 좌표는 r+1, c+1를 가리킨다.

가장 북서쪽은 0,0, 가장 남동쪽은 N-1,M-1

그냥 인덱스입니다. 입력을 잘 보고 헷갈리지 말아야합니다 !!

📚 새롭게 알게된 내용

1. 좌표계와 배열 인덱스는 다르다
   • 문제에서 (r, c)라고 표현하고, (0, 0)이 가장 북서쪽이라고 말하지만, 실제로는 그냥 2차원 배열의 인덱스일 뿐이다.
   • x는 가로(→), y는 세로(↓)의 의미를 갖지만, 배열에서는 board[y][x] 순으로 접근해야 하므로 항상 주의가 필요하다.

2. 방향 회전은 +3 % 4로 처리하면 깔끔하다
   • 북(0), 동(1), 남(2), 서(3) 기준으로 왼쪽 회전은 (dir + 3) % 4로 표현하면 된다.
   • 구현/시뮬레이션 문제에서 방향 회전은 자주 등장하므로 반드시 외워두면 좋다.

3. 청소 여부는 값으로 구분하면 된다
   • board[y][x] = 2처럼, 청소한 칸을 숫자 값으로 표현해도 된다. 중요한 건 일관성 있게 처리하는 것.
   • 꼭 2가 아니어도 상관없지만, “청소한 칸”이라는 상태 표현이 코드 내에 명확히 드러나야 한다.

4. 입력도 0-based 인덱스다
   • 문제 설명이 좌표처럼 느껴질 수 있지만, 입력값 자체는 0부터 시작하므로 -1 같은 보정은 필요 없다.
   • (3, 4)는 곧 board[3][4]를 의미한다.

[giljihun]

데미안 완전 시뮬레이션 + 어떤 알고리즘으로 풀어볼래의 정석 문제네요 ㅎㅎ
또 어떻게 보면 전형적인 DFS문제같기도하고요.

코드가 실제 세상을 반영한다는 가치가 담긴 직관적인 설계 아주 좋았습니다.
데미안 pr은 수도코드에도 ㅁ코멘트를 달고싶을 정도로 잘 읽히고 뭔가 같이 풀고있다라는 느낌이 들어요 ㅋㅋ

저는 큐기반 bfs로 다시 도전해보겠습니다.

[giljihun]

사소한 질문같기도 한데 궁금해서 여쭤볼게요!

이 파라미터가 4개인 함수를 봤을 때, 데미안은 어떤 파라미터가 가장 중요하다고 생각이 드시나요?
저는 뭔가 x,y를 앞에 두는게 어떤가? 하는 가벼운 생각이 들었습니다!
갑자기 파라미터의 순서에 따라서도 함수를 이해하는 가독성을 조금 더 높일 수 있지 않을까? 하는 생각이 들었네요 ㅋㅋ
물론 지금도 충분히 이해되는 순서입니다 !

[MuchanKim]

좋은 피드백이네요 길 저도 그런 생각이 들었습니다.

[bishoe01]

좋은 것 같습니다..! 저는 복잡할수록 파라미터 순서에서 뒤로 미루는 것 같아요.

[YooGyeongMo]

@giljihun 사실 길 이야기를 듣고 보니... 함수 파라미터 선정시에 중요도 혹은, 가독성을 생각하지 않는 경향이 있는거 같아요 ㅜㅜ 반성하게 됩니다. 사실 중요도 측면에서 생각하기 보다는 설계할때 일단 구현하고 보자라는 생각으로 함수에 다 때려넣을때 특히 dfs/bfs 풀때는 그냥 넣게 되는데 맞네요.. 생각해보니 x,y가 앞에있다면 ? 아주 좋았을꺼같아요.

• 다만ㅋㅋ dfs/bfs문제 푼걸보니 재귀일때 좌표는 뒤쪽에 찍는 경우가 많더군요 저는 생각하고 적어봐야겠어요 길 센세와 swift 컨벤션keeper @MuchanKim 조언이라면 받을어야죠 호호

[giljihun]

오.. 그렇군요 ㅎㅎ
저도 반성하는 부분이라 코멘트 남겨보았던 것입니다 !! 감사해요

[giljihun]

여기 코드에 의문이 있어요!

dfs를 들어가면, 현재 위치가 청소되었나? 체크하고 청소를 하잖아요

// 1. 현재 위치가 청소되지 않았다면 -> 청소
    if board[y][x] == 0 {
        board[y][x] = 2
    }

여기서 처리를 한다고 이해를 했는데,
메인코드에서 제자리 청소를 체킹하고 함수로 넘어가는 이유가 있을까요 ??

[YooGyeongMo]

오 길, 중복청소긴하네요. 다시 기억을 더듬어보니 , 저도 사실 처음에 그냥 애초에 청소한거라고 count하고 시작할까 아니면 어떻게할까 ? 고민했었는데요 .
즉, board[r][c] = 2를 한 이유는 dfs 안에서는 “청소 안 되어 있는 칸”만 청소하므로 시작 위치를 미리 청소 처리하고, result = 1로 시작해서 “방 1개는 청소함”이라고 셀 수 있게 한 것이란 의도가 있었어요.

만약에 저 코드가 없다면 dfs 내부에서 첫 청소가 일어나고, count = 0에서 시작해도 결과는 동일하다고 생각했어요. 즉, 시작 위치 청소를 어디서 정할지에 대한 생각 차이였던거같아요.

board[r][c] = 2         // 미리 청소했다고 선언하고
var result = 1          //  "1칸 청소했음" 으로 시작
dfs(result, d, c, r)    // 그래서 dfs에선 이미 청소됐다고 전제

혹시 답변이 되었을까용 ? 근데 사실 중복코드 같아서 리팩토링할 필요가 있어보입니다.

[giljihun]

좋은 답변 감사합니다!
코테를 하면 중복 코드가 정말 많아지죠!
물론 코테측면에서는 별 문제가 없으니 잘 짠 코드라고 생각해요!!
저도 이런 중복 코드에 대한 반성 & 인사이트를 얻게해주셔서 감사합니다. :)

[bishoe01]

문제가 엄청 복잡하다고 생각을 했는데, 이렇게 dfs로 정리된것 보니까 후진을 뒤로 빼주면 turnleft있는 깔끔한 dfs네요 잘봤습니다 ~ 그리고 이 범위 처리 해주는 것은 사람마다 다양하네요 isRange 함수로 안빼주고 그냥 continue 바로 해주니까 간결해서 보기 좋아요 다음에 한 번 사용해보겠습니다.

[YooGyeongMo]

@bishoe01 맞아요 핀쌤 저기서 저는 좀 고민했어요 오른쪽으로 돌지 왼쪽으로 돌지 아니면 뭐 어떤식으로해야 좀 더 효율적으로 계산할지, 사실 저 코드는 제가 이것이 코딩테스트다 나동빈 책에서 dfs/bfs 시에 저런식으로 많이체크를 먼저하고 후에 조건을 넣고 dfs 실행하는 순서를 가져서 그 구조를 외웠어서 그런거같아요. 좀 더 좋은 방식이 있으면 알려주시면 좋을꺼같아요 핀쌤

[bishoe01]

엄~청 예전에보고 본적이없네요...!
책은 가져왔어요!! 오늘가서 한 번 둘러보겠습니다 감사해요

[bishoe01]

청소기문제인데, 하면서 뭔가 색칠로 인식을 해서 주석이 색칠로 되어있습니다..! 의미는 같아요 ~

처음에 그냥 테두리만 안나가면 되는지알고 풀었는데, 1도 안되더라구요..! 저는 1은 이미 색칠된 공간으로 인식을 하고 풀다가 좀 오래 걸렸습니다..

이번까지만 좀 struct 쓰면서 프로그램스럽게 짜보는 연습을 했는데, 시간이 너무 오래걸려서 다음부터는 좀 시간진짜 타이머 재면서 1시간 안에 푸수 있게끔 커트라인을 둬보겠습니다.
근데 원래 이런식으로 잘 안짜버릇해서 좀 학습은 할 수 있었던 것 같아요.. 안바쁠때 어려운문제 가끔해보면 좋을듯?!

import Foundation

var Direction: [Int: (i: Int, j: Int)] = [0: (-1, 0), 1: (0, 1), 2: (1, 0), 3: (0, -1)]

struct Robot {
    var direction: Int
    var position: (i: Int, j: Int)
    let N: Int
    let M: Int
    var count = 1
    // 길 선생님문제에서본 좌표 판단 contains로 해주기
    func isRange(_ i: Int, _ j: Int) -> Bool {
        return (0 ..< self.N).contains(i) && (0 ..< self.M).contains(j)
    }

    mutating func turnLeft() {
        self.direction = (self.direction + 3) % 4
    }

    // 4방향중에 색칠할 곳 있나요 ?!
    func judgeAll(_ graph: [[Int]]) -> Bool {
        for dir in 0 ..< 4 {
            let next_move = Direction[dir]!
            let next_pos = (i: self.position.i + next_move.i, j: self.position.j + next_move.j)
            if self.isRange(next_pos.i, next_pos.j), graph[next_pos.i][next_pos.j] == 0 {
                return true
            }
        }
        return false
    }

    // 앞으로는 갈 수 있나요 ? (색칠 가능? )
    func judgeForward(_ graph: [[Int]]) -> Bool {
        let next_move = Direction[self.direction]!
        let next_pos = (i: self.position.i + next_move.i, j: self.position.j + next_move.j)
        return self.isRange(next_pos.i, next_pos.j) && graph[next_pos.i][next_pos.j] == 0
    }

    // 방향대로 이동했을때의 포지션
    func forwardPosition() -> (i: Int, j: Int) {
        let next_move = Direction[self.direction]!
        let next_pos = (i: self.position.i + next_move.i, j: self.position.j + next_move.j)
        return next_pos
    }

    // 후진
    func goBack() -> (i: Int, j: Int) {
        // 뒤돌기
        let next_move = Direction[(self.direction + 2) % 4]!
        let next_pos = (i: self.position.i + next_move.i, j: self.position.j + next_move.j)
        return next_pos
    }
}

func solution(_ N: Int, _ M: Int, _ robot: (i: Int, j: Int, d: Int), _ graph: [[Int]]) -> Int {
    var graph = graph
    var robot = Robot(direction: robot.d, position: (i: robot.i, j: robot.j), N: N, M: M)
    graph[robot.position.i][robot.position.j] = 2
    while true {
        // 4방향 중에 색칠할 곳 있어요 !
        if robot.judgeAll(graph) {
            주변탐방: for _ in 0 ..< 4 {
                // 있으니까 2번상황 -> 일단 좌회전
                robot.turnLeft()
                // 좌회전 하니까 이거 색칠 가능 ?
                if robot.judgeForward(graph) {
                    let nextPosition = robot.forwardPosition()
                    robot.position = nextPosition
                    // 0이랑 1을 피해서 그냥 2라고 달음
                    graph[nextPosition.i][nextPosition.j] = 2
                    robot.count += 1
                    break 주변탐방
                }
            }
        }
        else {
            let backPosition = robot.goBack()
            // 벽에 안닿으면서도 갈 수 있는 곳인지 판단
            if robot.isRange(backPosition.i, backPosition.j) && graph[backPosition.i][backPosition.j] != 1 {
                robot.position = backPosition
            }
            else {
                break
            }
        }
    }
    return robot.count
}

로직은 문제에 나온 순서대로 인것같아요. 방향도 있고 후진도하고 하다보니 좀 복잡해진듯..!

전체 로직

1. 4방향 중에 색칠할 곳 있는지 판단
   1 - 2. 그러면 이제부터 turnLeft해주면서 눈 앞에 색칠할 곳 있는지 판단
   1 - 3. 찾으면 count +1

2. 4방향중에 색칠할거 없음
   2 - 1. 그러면 후진해주면서 벽인지 판단
   2 - 2. 벽이 아니면 후진해주고 다시 1번으로 돌아가기
   2 - 3. 벽이면 끝내기

[MuchanKim]

다른분들 푼 거보면 확실히 코테를 준비하는 느낌이 확 드네요.(대충 고수라는 뜻)

전 효율보다는 구조적으로 잘짜는데 중점을 둔 것 같아요. 그렇지만. 잘짰다고는 생각이 안드네요.
기존에 하드코딩했다가 함수로 빼려니까 너무 복잡하게 하는 것 같고 머리아파서 내부에 함수로 분리해뒀어요. 근데 이게 중첩함수가 많아지니까 안좋아보이네요.

열거형도 잘 활용하고 싶어서 최근 구현문제에 많이 쓰고있는데 이번에 이거쓰느라 더 시간 걸린 듯 너무 어렵게 풀려고 했나봅니다~~

+ 데미안 코드랑 성능 비교해보려고 돌려봤는데 컴파일 에러뜨던데 코드 잘못올리신게 아닌가..! 확인부탁드리옵니다.

// 청소 상태 관리할 배열 필요함 - 0(청소 안됨), 1(청소됨), 2(벽)으로 저장하자
// 방향 전환은 dx, dy 배열로 관리하면 쉬울 듯 -> 열거형이 더 좋아보임. - 북(0), 동(1), 남(2), 서(3)
// 로봇 현재 위치/방향 따로 변수 관리하고, 계속 갱신해가면서 움직임 추적
// 1. 현재 위치 청소
// 2. 왼쪽부터 돌면서 갈 곳 있나 확인 (반시계 회전)
// - 청소할 곳 있으면 그리로 이동하고 1번으로 돌아가기
// - 4방향 모두 청소됐거나 벽이면 후진 시도
// 3. 후진도 못 하면 작업 종료, 청소한 칸 수 반환
// 로봇이 바라보는 방향 회전은 (dir + 3) % 4
// 후진은 현재 방향에서 정반대로 (dir + 2) % 4

import Foundation

typealias Position = (x: Int, y: Int)

enum Direction: Int {
    case north = 0
    case east = 1
    case south = 2
    case west = 3
    
    var move: Position {
        switch self {
        case .north: return (-1, 0)  
        case .east:  return (0, 1)   
        case .south: return (1, 0)  
        case .west:  return (0, -1)  
        }
    }
    
    // 반시계 방향 회전
    func turnLeft() -> Direction {
        return Direction(rawValue: (self.rawValue + 3) % 4)!
    }
    
    // 후진 방향 (180도 회전)
    func reverse() -> Direction {
        return Direction(rawValue: (self.rawValue + 2) % 4)!
    }
}

// input
let boardSize = readLine()!.split(separator: " ").map { Int($0)! }
let (N, M) = (boardSize[0], boardSize[1])

let robotInfo = readLine()!.split(separator: " ").map { Int($0)! }
var (r, c, d) = (robotInfo[0], robotInfo[1], robotInfo[2])

var map = Array(repeating: Array(repeating: 0, count: M), count: N)
for i in 0..<N {
    let row = readLine()!.split(separator: " ").map { Int($0)! }
    for j in 0..<M {
        if row[j] == 1 {
            map[i][j] = 2
        }
    }
}

func solution(position: Position, direction: Int, roomSize: (height: Int, width: Int)) -> Int {
    // 로봇의 현재 상태
    var currentPosition = position
    var currentDirection = Direction(rawValue: direction)!
    var numberOfCleanedBlocks = 0
    
    // 좌표가 맵 내에 있는지 확인하는 함수
    func isInBounds(_ position: Position) -> Bool {
        return position.x >= 0 && position.x < roomSize.height && 
               position.y >= 0 && position.y < roomSize.width
    }
    
    // 주어진 방향으로 이동했을 때의 새 위치 계산
    func positionAfterMove(from position: Position, direction: Direction) -> Position {
        let move = direction.move
        return (position.x + move.x, position.y + move.y)
    }
    
    while true {
        // 현재 위치 청소
        if map[currentPosition.x][currentPosition.y] == 0 {
            map[currentPosition.x][currentPosition.y] = 1
            numberOfCleanedBlocks += 1
        }
        
        var foundCleanableBlock = false
        
        for _ in 0..<4 {
            // 왼쪽으로 회전 (반시계 90도)
            currentDirection = currentDirection.turnLeft()
            
            // 회전 후 바라보는 방향의 위치 계산
            let nextPosition = positionAfterMove(from: currentPosition, direction: currentDirection)
            
            // 범위 내에 있고 청소할 수 있는 빈 공간인 경우
            if isInBounds(nextPosition) && map[nextPosition.x][nextPosition.y] == 0 {
                currentPosition = nextPosition  
                foundCleanableBlock = true
                break
            }
        }
        
        // 청소할 공간이 없는 경우 -> 후진 또는 종료
        if !foundCleanableBlock {
            // 후진할 위치
            let backPosition = positionAfterMove(from: currentPosition, direction: currentDirection.reverse())
            
            // 후진할 수 있는지 확인
            if isInBounds(backPosition) && map[backPosition.x][backPosition.y] != 2 {
                currentPosition = backPosition  
            } else {
                break
            }
        }
    }
    
    return numberOfCleanedBlocks
}

let res = solution(position: (r, c), direction: d, roomSize: (N, M))
print(res)

[MuchanKim]

입력 조건 주석으로 적어놓으시는거 굉장히 좋아보입니다!! 저도 이렇게 해야겠어요^~^

+ 입력 부분 가져다썼어용!

[sep037]

저는 너무 오래 걸려서 블로그에서 여러개 짜집기 했읍니다 ..
이렇게 이동 좌표 계산하고 머릿속으로 그려야 하는 문제들은 항상 겁 먹고 시작하는 것 같아요 (어려울 것 같다는)
데미안이 선사하신 로봇청소 문제를 발판 삼아 더 쉬운 좌표 문제(?)로 차근 차근 쌓아나가보려 합니다. 🥹
로봇 청소기를 혼자 푸는 그날까지
늦어서 죄송해요 ! ㅠ

//
//  main.swift
//  14503
//
//  Created by Seungeun Park on 5/19/25.
//

import Foundation

// 방향을 나타내는 상수: 북(0), 동(1), 남(2), 서(3)
// 각각의 방향에 대한 이동 좌표 변화량 (dy, dx)
let dy = [-1, 0, 1, 0] // 북, 동, 남, 서
let dx = [0, 1, 0, -1]

let size = readLine()!.split(separator: " ").map { Int($0)! }
let N = size[0], M = size[1]

let robotInit = readLine()!.split(separator: " ").map { Int($0)! }
var r = robotInit[0], c = robotInit[1], d = robotInit[2] // 로봇의 초기 위치와 방향

// 방의 상태 저장: 0은 청소 가능, 1은 벽
var map: [[Int]] = []
for _ in 0..<N {
    map.append(readLine()!.split(separator: " ").map { Int($0)! })
}

// 방문 여부 확인용 배열 (청소했는지 여부)
var cleaned = Array(repeating: Array(repeating: false, count: M), count: N)
var cleanedCount = 0 // 청소한 칸 개수

while true {
    // 현재 위치가 청소되지 않았으면 청소
    if !cleaned[r][c] {
        cleaned[r][c] = true
        cleanedCount += 1
    }

    var moved = false // 4방향 중 이동했는지 여부

    // 반시계 방향으로 4번까지 탐색
    for _ in 0..<4 {
        // 왼쪽 방향으로 회전
        d = (d + 3) % 4 // 북(0) → 서(3) → 남(2) → 동(1) 순서

        let nr = r + dy[d]
        let nc = c + dx[d]

        // 이동할 칸이 청소 안 된 빈 칸이면 이동
        if map[nr][nc] == 0 && !cleaned[nr][nc] {
            r = nr
            c = nc
            moved = true
            break // 전진했으므로 다시 1번부터 시작
        }
    }

    //네 방향 모두 청소 못하면 → 후진
    if !moved {
        let back = (d + 2) % 4 // 현재 방향의 반대 방향
        let br = r + dy[back]
        let bc = c + dx[back]

        // 뒤가 벽이면 종료
        if map[br][bc] == 1 {
            break
        } else {
            // 후진은 방향 그대로 유지하면서 위치만 이동
            r = br
            c = bc
        }
    }
}

print(cleanedCount)

[YooGyeongMo]

ㅇㅁㅇㄴㅁㄴㅇㄴㅁㅇ

[YooGyeongMo]

dㅘ 데미안 이렇게 접근하셧ㄱㄴ요 !