18-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 로봇 청소기 https://www.acmicpc.net/problem/14503

✔️ 소요된 시간

1h

✨ 수도 코드

저번에 준용님 pr이었던가요.
거의 동일한 문제인데 한번 다시 상기해보고자 풀어봤습니다.
방향 관련해서는 금방 구현했는데
전진, 4방향 탐색, 후진 구현에 조금 헤맸습니다.
아마 다른 분들은 쉽게 풀 수 있을 겁니다.

1. 우선 현재 위치의 cleaned를 true로 바꿔준 후 count++합니다.
2. 4방향을 탐색하기 위해 반시계 방향으로 회전 (turnLeft)하며
그 앞 칸이 전진할 수 있고 청소 되지 않은 칸인지 확인합니다.
3. 전진한다면 moved를 true로 바꿔주고 다시 1~2번을 반복합니다.
4. 제자리에 머물러 있는 경우(moved == false) 후진하고 후진 할 수 없다면
while문을 빠져나오고 count 를 반환합니다.

PCCP 연습 겸 앞으로 구현 문제 위주로 풀어봐야겠습니다.

📚 새롭게 알게된 내용

[kangrae-jo]

머리로는 쉽게 그려졌는데 코드로 구현하기가 살짝 빡세네요.

말씀하신대로 저번에 준용님 문제와 유사해서 문제 접근은 쉽게 한 것 같아요.
조금 어려운 점이었다면, 뒤로 후진할 때의 로직을 어떻게 처리해야하는가 였네요.

그리고 반시계방향? 이런것도 방향을 정하니까 살짝 헷갈리 더라구요.

dfs bfs문제는 항상 재밌는것 같네요. 좋은 문제 감사합니다.

CPP CODE

#include <iostream>
#include <vector>

#define PATH 0
#define WALL 1
#define VISITED 2

using namespace std;

int N, M, answer = 0;
vector<vector<int>> board;

int offset[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

void dfs(int y, int x, int d) {
    if (board[y][x] == PATH) {
        board[y][x] = VISITED;
        answer++;
    }

    for (int i = 0; i < 4; i++) {
        int d_ = (d + 3) % 4;
        int y_ = y + offset[d_][0];
        int x_ = x + offset[d_][1];

        if (0 <= y_ && y_ < N && 0 <= x_ && x_ < M && board[y_][x_] == PATH) {
            dfs(y_, x_, d_);
            return;
        }
        d = d_;
    }
    int backD = (d + 2) % 4;
    int backY = y + offset[backD][0];
    int backX = x + offset[backD][1];

    if (board[backY][backX] != WALL) dfs(backY, backX, d);
}

int main() {
    cin >> N >> M;
    
    int curY, curX, d;
    cin >> curY >> curX >> d;

    board = vector<vector<int>>(N, vector<int>(M));
    for (int y = 0; y < N; y++) for (int x = 0; x < M; x++)
            cin >> board[y][x];

    dfs(curY, curX, d);
    cout << answer << endl;

    return 0;
}

[kangrae-jo]

알고리즘 이지만 함수분리를 잘해서 보기 편한 것 같아서 좋네요!

[kangrae-jo]

근호님 코드에서 바로 적용가능한지는 모르갰지만,
이렇게 불리언 배열을 따로 생성하지 않고, map 배열 안의 값을 수정해서 방문 표시를 할 수 도 있을 것 같아요!

[kokeunho]

옹 다음 비슷한 유형 풀어볼 때 적용시켜보겠습니다!

[g0rnn]

입력이 (r, c) 인줄 몰라서 1시간을 헤맷네요.. 문제를 읽고 접근하는 방법이 좀 틀어져서 전에 풀었던 문제엿는데도 제가 이전에 작성한 코드와 많이 다르네요.

코드 자체는 강래님 처럼 dfs를 사용했습니다..(사실 중간에 dfs가 잘 안되서 참고를 좀 했습니다^^;) 코드가 길어지고 불필요한 메서드 분리가 다분한거 같아 다음부턴 더 잘 풀어보려 합니다.

고생하셨습니다.

code

import java.io.*;
import java.util.*;

public class Sol14503 {

    static int answer = 0;
    static int n;
    static int m;
    static Pos cur;
    static int dir; // 0: 상, 1: 우, 2: 하, 3: 좌
    static int[] dx = {0, 1, 0, -1};
    static int[] dy = {-1, 0, 1, 0};
    static int[][] grid;

    public static void main(String[] args) throws IOException {
        input();
        dfs();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        bw.write(String.valueOf(answer));
        bw.close();
    }

    private static void dfs() {
        if (grid[cur.y][cur.x] == 0) {
            cur.clean();
            answer++;
        }
        for (int t = 0; t < 4; t++) {
            dir = (dir + 3) % 4;
            if (cur.canMove(dir)) {
                cur.move(dir);
                dfs();
                return;
            }
        }
        if (cur.backward(dir)) {
            dfs();
        }
    }

    private static void input() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        int r = Integer.parseInt(st.nextToken());
        int c = Integer.parseInt(st.nextToken());
        cur = new Pos(c, r);
        dir = Integer.parseInt(st.nextToken());

        grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < m; j++) {
                grid[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        br.close();
    }

    private static class Pos {
        public int x;
        public int y;

        Pos(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public boolean canMove(int dir) {
            int nx = x + dx[dir];
            int ny = y + dy[dir];
            return 0 <= nx && nx < m && 0 <= ny && ny < n && grid[ny][nx] == 0;
        }

        public void move(int dir) {
            x += dx[dir];
            y += dy[dir];
        }

        public boolean backward(int dir) {
            dir = (dir + 2) % 4;
            int nx = x + dx[dir];
            int ny = y + dy[dir];
            if(0 <= nx && nx < m && 0 <= ny && ny < n && grid[ny][nx] != 1) {
                move(dir);
                return true;
            }
            return false;
        }

        public void clean() {
            grid[y][x] = 2;
        }
    }

}

[wnsmir]

문제를 읽어보니 전에 제가 PR했던 문제와 거의 유사한 구현문제였습니다.

특 기능을 순서대로 나열해준것은 대표적인 구현문제였습니다.
로직을 문제에서 알려주게때문에 쉽게 구현해나가면 됩니다.

제가 문제를 풀면서 고민했던 부분들은 반시계방향 회전을 어떻게 처리할것인가?
4가지 방향을 돌고난 뒤 청소할 방이 있다는 것을 어떻게 처리할것인가? 였습니다.
Found라는 불 변수를 활용해 4가지방을 돌고난 뒤 found가 false라면 더이상 전진할 곳이 없다고 판단하고 후진가능성을 판단하는 3번째 로직으로 가게끔 구현하였습니다.

45분정도 걸린것같습니다!

N, M = map(int, input().split())
r, c, d = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(N)]

def clean_room(n, m, r, c, d, grid):
    # 북, 동, 남, 서 방향
    dr = [-1, 0, 1, 0]
    dc = [0, 1, 0, -1]

    cleaned = 0

    while True:
        #현재 칸 청소
        if grid[r][c] == 0:
            grid[r][c] = 2  #청소 완료 표시
            cleaned += 1

        #주변 4칸 중 청소되지 않은 칸 확인
        found = False  #청소할 빈 칸이 있는지 체크
        for i in range(4):
            nd = (d + 3) % 4 #반시계 방향 회전
            nr, nc = r + dr[nd], c + dc[nd]

            if 0 <= nr < n and 0 <= nc < m and grid[nr][nc] == 0:
                d = nd  #회전
                r, c = nr, nc  #전진
                found = True
                break  #전진했으므로 즉시 루프 종료
            else:
                d = nd  #방향만 회전

        #청소할 칸이 없으면 후진 시도
        if not found:
            br, bc = r - dr[d], c - dc[d]
            if 0 <= br < n and 0 <= bc < m and grid[br][bc] != 1:
                r, c = br, bc  #후진
            else:
                break  #후진 불가 시 종료

    return cleaned

print(clean_room(N, M, r, c, d, grid))