29-wnsmir

[wnsmir]

🔗 문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/388353

✔️ 소요된 시간

30min

✨ 수도 코드

얼마전 치즈문제였나요?
굉장히 비슷해서 금방풀 수 있었습니다.

다만 그문제와 다른점은 이문제는 태두리가 없다는 것입니다...ㅜ
그래서 직접 패딩해주어 각 명령어마다 bfs를 수행해 외부를 0으로 만들었습니다.

치즈문제로 치면 외부공기가 0이되는것과 같습니다.

각 명령문을 돌며 알파벳이 두개나오면 그냥 반복문 두번 돌면서 1로 바꿔주고, 1은 다시 bfs를 통해 외부와 접촉하는 1은 0으로 만들어줍니다.

다만 살짝 햇갈렸던 부분이 있었다면, 지게차로직의 뒤에도 bfs를 달아주어야 합니다.
크레인은 당연히 1로 바꾸어줬다가 그 1이 0과 붙어있다면 0으로 바꿔주는 bfs가 필요하다면,

지게차도 만약 외부와 붙어있는 짐을 없앴을떄 내부에 1이 있었다면 그 1을 다른 명령어가 실행되기전에 0으로 바꿔줘야하기 떄문입니다.

즉 지게차든 크레인이든 각 로직이 끝나고 bfs로 외부와의 접촉을 항상 업데이트해주어야 합니다.

from collections import deque

def solution(storage, requests):
    n = len(storage)
    m = len(storage[0])

    # 0 패딩
    grid = [[0] * (m+2)]
    for row in storage:
        grid.append([0] + list(row) + [0])
    grid.append([0] * (m+2))

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

    def bfs():
        visited = [[False] * (m+2) for _ in range(n+2)]
        queue = deque()
        queue.append((0, 0))
        visited[0][0] = True
        while queue:
            x, y = queue.popleft()
            for i in range(4):
                nx = x + dx[i]
                ny = y + dy[i]
                if 0 <= nx < n+2 and 0 <= ny < m+2 and not visited[nx][ny]:
                    if grid[nx][ny] in (0, 1):
                        visited[nx][ny] = True
                        if grid[nx][ny] == 1:
                            grid[nx][ny] = 0
                        queue.append((nx, ny))
    
    for request in requests:
        selected = []

        # 크레인
        if len(request) == 2:
            target = request[0]
            for x in range(1, n+1):
                for y in range(1, m+1):
                    if grid[x][y] == target:
                        selected.append((x, y))

            for x, y in selected:
                grid[x][y] = 1
            
            bfs()

        # 지게차
        elif len(request) == 1:
            target = request
            for i in range(1, n + 1):
                for j in range(1, m + 1):
                    if grid[i][j] == target:
                        for d in range(4):
                            ni = i + dx[d]
                            nj = j + dy[d]
                            if grid[ni][nj] == 0:
                                selected.append((i, j))
                                break
            for x, y in selected:
                grid[x][y] = 0
            bfs()

    # 남은물건 개수
    count = 0
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            if grid[i][j] not in (0, 1):
                count += 1

    return count

📚 새롭게 알게된 내용

[9kyo-hwang]

3월의 와타사기 원트클을 해놨군요(뿌듯)

저는 문자열 배열로 주어지는 storage 정보를 패딩시킨 int 2차원 배열로 다 매핑시켰습니다. 그리고 '확인 완료된 칸'은 -1로 두었습니다.

int N, M;
vector<vector<int>> GStorage;

int solution(vector<string> Storage, vector<string> Requests) 
{
    N = Storage.size(); M = Storage[0].size();
    GStorage.assign(N + 2, vector<int>(M + 2, -1));  // 기본값은 -1
    
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= M; ++j)
        {
            GStorage[i][j] = Storage[i - 1][j - 1] - 'A';  // A ~ Z를 0 ~ 25로 대응
        }
    }
    
    ...
}

그리고 request를 확인하면서 길이가 1이면 지게차, 2라면 크레인을 사용하는 요청을 수행하도록 했습니다. 이 때 최초 Answer 변수 값을 Storage 크기로 초기화한 뒤, 각 요청에서 '꺼낸 컨테이너 개수'를 반환하게 해서 이를 계속 빼는 식으로 처리했습니다. 이러면 자연스럽게 요청이 종료되면 '남은 컨테이너 개수'를 즉시 반환할 수 있기 때문이죠.

int solution(vector<string> Storage, vector<string> Requests) 
{
    ...
    
    int Answer = N * M;
    
    for(const string& Request : Requests)
    {
        if(Request.length() == 1)
        {
            Answer -= DeliveryByForklift(Request[0] - 'A');
        }
        else
        {
            Answer -= DeliveryByCrane(Request[0] - 'A');
        }
    }
    
    return Answer;
}

지게차 사용하는 건 언급하신 대로 치즈 문제 푼 것과 거의 동일하게 해결할 수 있습니다. 단 순회를 진행할 때

1. 인접칸이 찾는 컨테이너라면 개수를 카운팅하고 더 이상 접근하지 못하도록 storage 배열에 -1을 마킹하기
2. 컨테이너가 꺼내진 칸이라면 다음 순회때 탐색할 후보로 지정

이 두 가지를 적절히 수행하는 게 키였던 것 같습니다.

const vector<pair<int, int>> Offset
{
    {-1, 0},
    {0, 1},
    {1, 0},
    {0, -1}
};

bool OutOfBound(int x, int y)
{
    return !(0 <= x && x <= N + 1 && 0 <= y && y <= M + 1);
}

int DeliveryByForklift(const int Container)
{
    int NumDelivery = 0;
    
    queue<pair<int, int>> Q;
    Q.emplace(0, 0);
    
    vector<vector<bool>> Visited(N + 2, vector<bool>(M + 2, false));
    Visited[0][0] = true;
    
    while(!Q.empty())
    {
        const auto [x, y] = Q.front();
        Q.pop();
        
        for(const auto& [dx, dy] : Offset)
        {
            int nx = x + dx, ny = y + dy;
            if(OutOfBound(nx, ny) || Visited[nx][ny])
            {
                continue;
            }
            
            Visited[nx][ny] = true;
            if(GStorage[nx][ny] == Container)  // 찾는 컨테이너라면
            {
                NumDelivery++;
                GStorage[nx][ny] = -1;  // 꺼내기
            }
            else if(GStorage[nx][ny] == -1)  // 이미 꺼내진 칸이라면
            {
                Q.emplace(nx, ny);  // 다음 순회때 확인해야 할 칸
            }
        }
    }
    
    return NumDelivery;
}

이런 식으로 처리하면 크레인에서는 그냥 2중 반복문 순회하면서 해당 컨테이너 칸만 처리해주면 됩니다.

int DeliveryByCrane(const int Container)
{
    int NumDelivery = 0;
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= M; ++j)
        {
            if(GStorage[i][j] == Container)
            {
                GStorage[i][j] = -1;
                NumDelivery++;
            }
        }
    }
    
    return NumDelivery;
}

전체 코드

#include <string>
#include <vector>
#include <queue>

using namespace std;

int N, M;
vector<vector<int>> GStorage;
const vector<pair<int, int>> Offset
{
    {-1, 0},
    {0, 1},
    {1, 0},
    {0, -1}
};

bool OutOfBound(int x, int y)
{
    return !(0 <= x && x <= N + 1 && 0 <= y && y <= M + 1);
}

int DeliveryByForklift(const int Container)
{
    int NumDelivery = 0;
    
    queue<pair<int, int>> Q;
    Q.emplace(0, 0);
    
    vector<vector<bool>> Visited(N + 2, vector<bool>(M + 2, false));
    Visited[0][0] = true;
    
    while(!Q.empty())
    {
        const auto [x, y] = Q.front();
        Q.pop();
        
        for(const auto& [dx, dy] : Offset)
        {
            int nx = x + dx, ny = y + dy;
            if(OutOfBound(nx, ny) || Visited[nx][ny])
            {
                continue;
            }
            
            Visited[nx][ny] = true;
            if(GStorage[nx][ny] == Container)
            {
                NumDelivery++;
                GStorage[nx][ny] = -1;
            }
            else if(GStorage[nx][ny] == -1)
            {
                Q.emplace(nx, ny);
            }
        }
    }
    
    return NumDelivery;
}

int DeliveryByCrane(const int Container)
{
    int NumDelivery = 0;
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= M; ++j)
        {
            if(GStorage[i][j] == Container)
            {
                GStorage[i][j] = -1;
                NumDelivery++;
            }
        }
    }
    
    return NumDelivery;
}

int solution(vector<string> Storage, vector<string> Requests) 
{
    N = Storage.size(); M = Storage[0].size();
    GStorage.assign(N + 2, vector<int>(M + 2, -1));
    
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= M; ++j)
        {
            GStorage[i][j] = Storage[i - 1][j - 1] - 'A';
        }
    }
    
    int Answer = N * M;
    
    for(const string& Request : Requests)
    {
        if(Request.length() == 1)
        {
            Answer -= DeliveryByForklift(Request[0] - 'A');
        }
        else
        {
            Answer -= DeliveryByCrane(Request[0] - 'A');
        }
    }
    
    return Answer;
}

[wnsmir]

패딩 말고 다른 방법이 있을까 잠시 고민했는데 실전이었다면 망설임 없이 패딩을 썼을 것 같더라고요,, 결국 패딩으로 풀었는데, 같은 방식으로 푸셨네요!

[kangrae-jo]

재밌는 문제네요.
예전에 풀었던것 같기도 합니다.

저는 패딩을 하지않고 풀었습니다.
만약 다음으로 이동할 board가 비어있거나, 방문되지 않았을 경우에만 큐에 넣고,
큐에서 꺼내었을 때 가장자리면 true를 반환하는 식으로 체크를 했어요.

그리고 또 한가지 주의할 점이라면,
지게차로 알파벳을 지울때, 딱 그 시점에서 지게차로 꺼낼 수 있는 녀석들만 꺼내야 한다는 점이었던 것 같아요.

예를 들어 A하나가 치워지면 그안에 A를 꺼낼수 있는 상황은... 문제에서 요구하는 바가 아닌거죠.
저는 그래서 꺼낼수 있는 녀석들의 좌표를 저장해놓고 각 쿼리의 마지막에 처리해주었습니다.

좋은문제 감사합니다.

#include <string>
#include <vector>
#include <queue>

using namespace std;

const int EMPTY = 0;
const int OFFSET[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

int n, m;
vector<vector<int>> board;

bool isIn(int y, int x) { return 0 <= y && y < n && 0 <= x && x < m; }
bool isOutLine(int y, int x) { return y == 0 || y == n - 1 || x == 0 || x == m - 1; }

bool canRemove(int y, int x, int c){
    vector<vector<bool>> visited(n, vector<bool> (m, false));
    
    queue<pair<int, int>> q;
    q.push({y, x});
    visited[y][x] = true;
    
    while (!q.empty()) {
        auto [curY, curX] = q.front();
        q.pop();
        
        if (isOutLine(curY, curX)) return true;
        
        for (int dir = 0; dir < 4; dir++) {
            int nextY = curY + OFFSET[dir][0];
            int nextX = curX + OFFSET[dir][1];
            
            if (isIn(nextY, nextX) && board[nextY][nextX] == EMPTY && !visited[nextY][nextX]) {
                q.push({nextY, nextX});
                visited[nextY][nextX] = true;
            }
        }
    }
    
    return false;
}

int solution(vector<string> storage, vector<string> requests) {
    n = storage.size();
    m = storage[0].size();
    
    board = vector<vector<int>> (n, vector<int> (m));
    for (int y = 0; y < n; y++) {
        for (int x = 0; x < m; x++) {
            board[y][x] = storage[y][x];
        }
    }
    
    for (string request : requests) {
        int c = request[0];
        
        if (request.size() == 2) { // all
            for (int y = 0; y < n; y++) {
                for (int x = 0; x < m; x++) {
                    if (board[y][x] == c) board[y][x] = EMPTY;
                }
            }
        } else { // outline
            vector<pair<int, int>> result;
            for (int y = 0; y < n; y++) {   
                for (int x = 0; x < m; x++) {
                    if (board[y][x] == c && canRemove(y, x, c)) result.push_back({y, x});
                }
            }
    
            for (auto [y, x] : result) board[y][x] = EMPTY;
        }
    }
    
    int answer = 0;
    for (int y = 0; y < n; y++) {
        for (int x = 0; x < m; x++) {
            if (board[y][x] != EMPTY) answer++;
        }
    }
        
    return answer;
}

[kangrae-jo]

예전에 풀었던 기억으로 날먹한 것 같아서 자바로도 해봤습니다.

자바는 스트링을 다루기까다로워서 char[][]로 변환한 뒤 동일한 로직으로 문제를 해결했습니다.

Java Code

import java.util.*;

class Solution {

    static final int[][] OFFSET = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    static int n, m;

    public int solution(String[] storage, String[] requests) {
        n = storage.length;
        m = storage[0].length();

        char[][] board = new char[n][m];
        for (int i = 0; i < n; i++) {
            board[i] = storage[i].toCharArray();
        }

        for (String request : requests) {
            char c = request.charAt(0);

            // 크레인
            if (request.length() == 2) {
                for (int y = 0; y < n; y++) {
                    for (int x = 0; x < m; x++) {
                        if (board[y][x] == c) {
                            board[y][x] = '0';
                        }
                    }
                }
            }
            // 지게차
            else {
                Queue<Pos> q = new LinkedList<>();
                for (int y = 0; y < n; y++) {
                    for (int x = 0; x < m; x++) {
                        if (board[y][x] == c && canRemove(board, y, x)) {
                            q.add(new Pos(y, x));
                        }
                    }
                }

                while (!q.isEmpty()) {
                    Pos p = q.poll();
                    board[p.y][p.x] = '0';
                }
            }
        }

        int answer = 0;
        for (int y = 0; y < n; y++) {
            for (int x = 0; x < m; x++) {
                if (board[y][x] != '0') answer++;
            }
        }

        return answer;
    }

    private static boolean canRemove(char[][] board, int y, int x) {
        boolean[][] visited = new boolean[n][m];
        Queue<Pos> q = new LinkedList<>();
        q.add(new Pos(y, x));
        visited[y][x] = true;

        while (!q.isEmpty()) {
            Pos cur = q.poll();

            if (isOutLine(cur.y, cur.x)) return true;

            for (int dir = 0; dir < 4; dir++) {
                int nextY = cur.y + OFFSET[dir][0];
                int nextX = cur.x + OFFSET[dir][1];
                if (isIn(nextY, nextX) && !visited[nextY][nextX] && board[nextY][nextX] == '0') {
                    q.add(new Pos(nextY, nextX));
                    visited[nextY][nextX] = true;
                }
            }
        }

        return false;
    }

    private static boolean isOutLine(int y, int x) {
        return y == 0 || y == n - 1 || x == 0 || x == m - 1;
    }

    private static boolean isIn(int y, int x) {
        return 0 <= y && y < n && 0 <= x && x < m;
    }

    private static class Pos {
        int y, x;

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

}

[kokeunho]

저도 패딩 처리하여 map을 다시 구성하였습니다.

그리고 request의 길이가 2, 1로 나누어
1이면 (0, 0)에서 bfs를 시작하여 외부와 접촉된 컨테이너 중 request해 해당하는 char를 제거하였습니다.
2라면 전체 map에서 request에 해당하는 ch를 모두 제거해주었습니다.

수고하셨습니다.

Details

import java.util.*;

class Solution {
    static char[][] map;
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};
    
    public int solution(String[] storage, String[] requests) {
        map = new char[storage.length+2][storage[0].length()+2];
        
        for (int i = 0; i < map.length; i++) {
            Arrays.fill(map[i], '-');
        }
        
        for (int i = 0; i < storage.length; i++) {
            String line = storage[i];
            for (int j = 0; j < line.length(); j++) {
                map[i+1][j+1] = line.charAt(j);               
            }
        }
        
        processReq(requests);
        
        return countContainer();
    }
    void processReq(String[] requests) {
        for (String request : requests) {
            char ch = request.charAt(0);
            if (request.length() == 1) {
                bfs(0, 0, ch);
            } else {
                removeCh(ch);
            }
        }
    }
    void bfs(int x, int y, char ch) {
        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[map.length][map[0].length];
        queue.add(new int[]{x, y});
        visited[x][y] = true;
        
        while(!queue.isEmpty()) {
            int[] current = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nx = current[0] + dx[i];
                int ny = current[1] + dy[i];
                if (nx >= 0 && nx < map.length && ny >= 0 && ny < map[0].length && !visited[nx][ny]) {
                    if (map[nx][ny] == '-') {
                        queue.add(new int[]{nx, ny});
                        visited[nx][ny] = true;
                    } 
                    if (map[nx][ny] == ch) {
                        map[nx][ny] = '-';
                        visited[nx][ny] = true;
                    }
                }
            }
        }
    }
    void removeCh(char ch) {
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                if (map[i][j] == ch) {
                    map[i][j] = '-';
                }
            }
        }
    }
    int countContainer() {
        int count = 0;
        
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                if (map[i][j] != '-') count++;
            }
        }
        return count;
    }

}

[g0rnn]

파이썬은 어렵군요...ㅋㅋㅋ 적응이 안되네요. 저도 패딩을 넣고 외곽에서부터 bfs로 탐색했는데 파이썬은 시간초과가 나네요ㅜ 1시간동안 머리 싸매다가 그냥 자바로 갈아탔습니다 :)

같은 로직을 자바로 구현했을땐 30분만에 풀 수 있었습니다. 역시 익숙한게 최고네요

import java.util.*;

class Solution {
    char[][] container;
    int n, m;
    int[][] offset = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        
    public int solution(String[] storage, String[] requests) {
        n = storage.length;
        m = storage[0].length();
        int answer = n * m;
        
        container = padding(storage);
        
        for (String req : requests) {
            if (req.length() == 1){
                answer -= one(req.charAt(0));
            } else {
                answer -= two(req.charAt(0));
            }
        }
        return answer;
    }
    
    private char[][] padding(String[] storage) {
        char[][] ret = new char[n+2][m+2];
        Arrays.fill(ret[0], ' ');
        Arrays.fill(ret[n+1], ' ');
        for (int i = 0; i < n; i++) {
            ret[i+1][0] = ' ';
            ret[i+1][m+1] = ' ';
            for (int j = 0; j < m; j++) {
                ret[i+1][j+1] = storage[i].charAt(j);
            }
        }
        return ret;
    }
    
    private int one(char target) {
        int count = 0;
        Queue<int[]> q = new ArrayDeque<>();
        boolean[][] visited = new boolean[n+2][m+2];
        q.add(new int[]{0, 0});
        visited[0][0] = true;
        
        while (!q.isEmpty()) {
            int x = q.peek()[0];
            int y = q.poll()[1];
            
            for (int[] o : offset) {
                int nx = x + o[0];
                int ny = y + o[1];
                if (nx < 0 || nx >= m+2 || ny < 0 || ny >= n + 2) continue;
                if (visited[ny][nx]) continue;
                if (container[ny][nx] == target) {
                    visited[ny][nx] = true;
                    container[ny][nx] = ' ';
                    count++;
                }
                else if (container[ny][nx] == ' ') {
                    visited[ny][nx] = true;
                    q.offer(new int[]{nx, ny});
                }
            }
        }
        //System.out.println("one: "+count);
        return count;
    }
    
    private int two(char target) {
        int count = 0;
        for (int i = 0; i < n+2; i++) {
            for (int j = 0; j < m+2; j++) {
                if (container[i][j] == target) {
                    container[i][j] = ' ';
                    count++;
                }
            }
        }
        //System.out.println("two: "+count);
        return count;
    }
}