30-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[치즈]

✔️ 소요된 시간

1h 30m...

✨ 수도 코드

오랜만이네요.
오늘은 재밌는 구현 문제 들고와봤습니다.
상어시리즈보다는 훨씬 쉽습니다.

저는 처음에 이 문제를 보고 이렇게 생각을 했어요.

1. (0,0)으로 부터 시작되는 "외부 공기"를 파악
2. N*M board를 살펴보며 (board[y][x] == 치즈 && 2면 이상이 "외부 공기")면 녹이기
3-1. "내부 공기" 를 "외부 공기"로 만들기 위해서 다시 1번으로
3-2. 더 이상 녹일 치즈가 없다면 종료

음.. 근데 저는 이 방식은 N과 M이 최대 100이기 때문에 시간 초과가 난다고 생각했어요.

2 * N최대 * M최대 * 날짜 최대 = 2 * 100 * 100 * 50

// 2를 곱한 이유는 수도코드 1번과 2번에서 N*M 이라서.
// 그러나 수도 코드 1번 과정은 bfs라서 생각보다 적음 (매번 N*M은 아님)
// 날짜 최대는 모서리 제외 모든칸이 치즈일때... 이견있으면 말해주세요

그런데 결론만 먼저 말씀드리자면 이렇게 해도 됩니다....
저는 그걸 모르고 뺑 둘러 갔네요.
그래도 틀린 풀이도 살짝 말씀드려볼게요.

위 방식의 문제는 수도코드 1, 2번에서 시간이 오래 걸리기 때문이라고 생각했어요.
그래서 현재 녹아있지 않은 치즈를 큐에 넣고, 현재 "외부공기"를 큐에넣고 이리저리 굴리는... 그런걸 했어요.

테케는 맞았지만, 메모리 초과가 뜨더라구요.
아마 특정 케이스에서 큐가 무한 팽창 했나봐요..

그래서 방법을 생각하던 도중 '처음으로 생각한 방식으로 한번 해보자 시간초과가 나는지 궁금하네' 라는 생각이 났어요.
구현을 해보니.. 정답이었습니다.

여러분들도 어렵게 생각하지 말고 쉽게 생각해서 바로 풀어보시길 바랍니다.

+) 아 완성된 코드에서는 resetAir 도 있어서 시간복잡도가 *2 가 아니라 *3 인것 같네요.

📚 새롭게 알게된 내용

c++에서 1초는 약 100,000,000번 연산이 된다고 하네요.
이 문제는 약 1,000,000번 연산이 필요하니 통과인가 봅니다.

[kokeunho]

처음에 내부 공간 때문에 어떻게 처리해야 하나 고민했습니다.

그래도 상어문제를 풀다와서일까요. 비교적 쉽게 풀 수 있었습니다.
(0, 0)지점에서부터 bfs로 0인 값을 따라가면서 치즈가 있는 값을 만나면 해당 치즈 지점의 접촉면 값을 +1 해주고
bfs가 끝난 시점에 접촉면 값이 2이상인 치즈를 제거해주었습니다.
내부 공간은 bfs로 어차피 도달할 수 없으니 신경쓰지 않아도 됩니다.

이를 치즈가 모두 없어질 때까지 반복하여 답을 얻을 수 있었습니다.

재밌는 문제였습니다. 수고하셨습니다~!!@@

Details

import java.util.*;

public class Main {
    static int N, M;
    static int[][] map;
    static boolean[][] visited;
    static int[][] contact;
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();
        M = sc.nextInt();
        map = new int[N][M];

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                map[i][j] = sc.nextInt();
            }
        }

        visited = new boolean[N][M];
        contact = new int[N][M];

        int deleteCount = 0;
        while (true) {
            if (checkMap()) {
                bfs(0, 0);
                deleteCheese();
                deleteCount++;
                initArr();
            } else {
                break;
            }
        }
        System.out.println(deleteCount);
    }
    static void bfs (int x, int y) {
        Queue<int[]> queue = new LinkedList<>();
        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 < N && ny >= 0 && ny < M) {
                    if (map[nx][ny] == 0 && !visited[nx][ny]) {
                        queue.add(new int[]{nx, ny});
                        visited[nx][ny] = true;
                    }
                    if (map[nx][ny] == 1) contact[nx][ny] += 1;
                }
            }
        }
    }
    static boolean checkMap() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (map[i][j] == 1) return true;
            }
        }
        return false;
    }
    static void deleteCheese() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (contact[i][j] >= 2) map[i][j] = 0;
            }
        }
    }
    static void initArr() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                visited[i][j] = false;
                contact[i][j] = 0;
            }
        }
    }
}

[9kyo-hwang]

조금 더 심플하게 접근할 수 있는 것이, (0, 0) 위치에서 bfs를 순회해 빈 칸으로만 이동할 수 있게 하면 자연스럽게 1. 각 치즈 별 공기에 접촉한 횟수를 획득할 수 있으며 2. 치즈 안쪽의 빈 공간은 탐색하지 않게 됩니다.

vector<vector<int>> GetNumContactsCheeses() {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(N, vector<bool>(M, false));
    
    q.emplace(0, 0);
    visited[0][0] = true;
    
    vector<vector<int>> numContactsCheeses(N, vector<int>(M, 0));
    
    // 빈 칸으로만 이동할 수 있는 bfs
    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;
            }
            
            if(isCheese[nx][ny]) {  // 다음 칸이 치즈라면 공기와 맞닿는 것
                numContactsCheeses[nx][ny]++;
            } else {  // 아니라면 큐잉
                visited[nx][ny] = true;
                q.emplace(nx, ny);
            }
        }
    }
    
    return numContactsCheeses;
}

이런 식으로 한 번 bfs를 순회할 때마다 모든 치즈 별로 "공기에 몇 번 접촉했는가"를 획득할 수 있습니다. 그러면 이 정보를 기반으로

for(int i = 0; i < N; ++i) {
    for(int j = 0; j < M; ++j) {
        if(numContactsCheeses[i][j] >= 2) {
            isCheese[i][j] = false;
        }
    }
}

2회 이상 공기에 접촉한 치즈만 녹이면(여기서는 bool 값을 false로 세팅) 됩니다.

이 2가지 과정을 "모든 치즈가 녹을 때까지" 반복하고, 그 루프 횟수를 출력하면 됩니다.

#include <bits/stdc++.h>

using namespace std;

int N, M;
vector<vector<int>> isCheese;
const vector<pair<int, int>> OFFSET {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

inline bool OutOfBound(int x, int y) {
    return x < 0 || x >= N || y < 0 || y >= M;
}

bool IsAllMelted() {
    for(int i = 0; i < N; ++i) {
        for(int j = 0; j < M; ++j) {
            if(isCheese[i][j]) {
                return false;
            }
        }
    }
    
    return true;
}

vector<vector<int>> GetNumContactsCheeses() {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(N, vector<bool>(M, false));
    
    q.emplace(0, 0);
    visited[0][0] = true;
    
    vector<vector<int>> numContactsCheeses(N, vector<int>(M, 0));
    
    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;
            }
            
            if(isCheese[nx][ny]) {
                numContactsCheeses[nx][ny]++;
            } else {
                visited[nx][ny] = true;
                q.emplace(nx, ny);
            }
        }
    }
    
    return numContactsCheeses;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    cin >> N >> M;
    isCheese.resize(N, vector<int>(M));
    
    for(auto& row : isCheese) {
        for(auto& col : row) {
            cin >> col;
        }
    }
    
    int tick;
    for(tick = 0; !IsAllMelted(); ++tick) {
        vector<vector<int>> numContactsCheeses = GetNumContactsCheeses();
        
        for(int i = 0; i < N; ++i) {
            for(int j = 0; j < M; ++j) {
                if(numContactsCheeses[i][j] >= 2) {
                    isCheese[i][j] = false;
                }
            }
        }
    }
    
    cout << tick;

    return 0;
}

[kangrae-jo]

조금 더 심플하게 접근할 수 있는 것이 ...

그렇네요. 그냥 외부에서 bfs 돌리고
각 치즈가 외부 공기랑 몇 번(?) 접촉했는지 보면 되는 군요

[g0rnn]

전 문제에서 가장자리에는 치즈를 놓지 않는다고 가정해서 외부에서 bfs를 돌렸습니다.

방문하는 위치가 치즈라면 cheese[y][x] = true 해두고, 이미 방문한 치즈라면 제거해야할 치즈리스트에 삽입하였습니다. 두 번 방문했다는건 가장자리라는 뜻이니깐요

재밌는 문제 감사합니다 :0 고생하셨어요

package beakjoon;

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

public class Sol2638_1 {
    static int n, m;
    static int[][] board;
    static int[][] offset = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) 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());
        board = new int[n][m];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < m; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        br.close();

        System.out.println(melt());
    }

    private static int melt() {
        int hour = 0;
        List<int[]> pos;
        while (true) {
            pos = bfs();
            if (pos.isEmpty()) break;
            for (int[] p : pos) {
                int x = p[0], y = p[1];
                board[y][x] = 0;
            }
            hour++;
        }
        return hour;
    }

    private static List<int[]> bfs() {
        List<int[]> corner = new ArrayList<>();
        Queue<int[]> q = new ArrayDeque<>();
        boolean[][] visited = new boolean[n][m];
        boolean[][] cheese = new boolean[n][m];

        q.offer(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 || ny < 0 || ny >= n) continue;
                if (visited[ny][nx]) continue;
                if (board[ny][nx] == 1) {
                    if (cheese[ny][nx]) corner.add(new int[]{nx, ny});
                    cheese[ny][nx] = true;
                    continue;
                }
                q.offer(new int[]{nx, ny});
                visited[ny][nx] = true;
            }
        }
        return corner;
    }
}

[wnsmir]

상어문제를 워낙많이 풀다보니까 이문제는 20분조금 안되어 다풀었네요

처음에 문제를 대충읽어 공기에 접촉하면 전부 턴종료전에 0으로 바꿔주었다가 틀려서 다시봤습니다.
내부공기 외부공기는 다르더라구요,,

문제는 착하게 외부태두리를 무조건 공기로 두게 해놓았습니다.
이유를 바로 파악한게 어차피 외부공기는 태두리와 접해있는곳이라 0,0에서 bfs를 돌리면 외부공기는 하나의 덩어리가 됩니다.

즉 외부공기를 bfs를 통해 하나의 덩어리로 만들어주고, 매턴마다 외부공기와 2개이상 접촉한 치즈는 melt 리스트에 넣어주어 개수를 새고 다시 0으로 바꾸어줍니다.

다음턴에 다시 0,0 bfs를 1회 진행하여 외부공기에 추가해주고 다시 녹일 치즈를 선정해주었습니다.

from collections import deque

R, C = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(R)]
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

turn = 0
last_cheezes = 0

while True:
    # 남은 치즈 개수 세기
    cheezes = sum(grid[i][j] == 1 for i in range(R) for j in range(C))
    if cheezes == 0:
        print(turn)
        break
    last_cheezes = cheezes
    turn += 1

    # 외부 공기만 BFS로 표시
    air = [[False]*C for _ in range(R)]
    queue = deque()
    queue.append((0, 0))
    air[0][0] = True

    while queue:
        x, y = queue.popleft()
        for d in range(4):
            nx, ny = x + dx[d], y + dy[d]
            # 외부공기가 아니면서 일반공기라면
            if 0 <= nx < R and 0 <= ny < C and not air[nx][ny] and grid[nx][ny] == 0:
                air[nx][ny] = True
                queue.append((nx, ny))

    # 외부 공기와 접촉한 치즈 위치 수집
    melt = []
    for x in range(R):
        for y in range(C):
            if grid[x][y] == 1:
                count = 0
                for d in range(4):
                    nx, ny = x + dx[d], y + dy[d]
                    if air[nx][ny]:
                        count += 1
                    if count >1:
                        melt.append((x, y))
                        break

    # 치즈 녹이기
    for x, y in melt:
        grid[x][y] = 0