17-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 안전 영역 https://www.acmicpc.net/problem/2468

✔️ 소요된 시간

40min

✨ 수도 코드

우선 2차원 배열을 두 개 사용합니다.
각 원소의 높이를 담고 있는 map[][]과 방문 여부를 담고 있는 visited[][]를 사용하였습니다.

map에 해당 지점의 높이를 대입하면서 map에서 가장 높은 지점의 높이 max_height를 구합니다.

        int max_area = 0;
        for (int h = 0; h <= max_height; h++) {
            visited = new boolean[n][n];
            int safe_area = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (!visited[i][j] && map[i][j] > h) {
                        dfs(i, j, h);
                        safe_area++;
                    }
                }
            }
            max_area = Math.max(max_area, safe_area);
        }

침수 높이를 0에서 max_height까지 늘려가면서
방문하지 않았고 침수되지 않은(해당 지점 높이 > max_height) 지점에서
dfs를 실행하고 safe_area를 +1 합니다.
그리고 각 침수 높이에서 기존의 max_area(최대 안전 영역)과 safe_area를 비교하여
max_area를 갱신합니다.

📚 새롭게 알게된 내용

이전 차시에 이어 그래프 탐색의 감을 이어가기 위하여
dfs 문제를 골랐습니다.
처음에는 풀면서 너무 코드가 더럽지 않나 싶었는데 풀리더군요..
혹시 더 나은 코드가 있다면 한 수 부탁드립니다~!

[kangrae-jo]

이렇게 해서 h의 탐색 범위를 줄이셨군요! 좋은 아이디어네요

[kangrae-jo]

살짝 빡세네요...

dfs 또는 bfs 를 사용해서 영역의 개수를 구하는 문제 + 브루트 포스로 모든 h의 경우 조사

이렇게 두가지 문제를 섞어놓으니까 내가 잘 하고 있는지 인지가 잘 안되더라고요...

1차 구현을 끝내고 실행을 시켜봤습니다.
근데... 5x5 면 25, 7x7 이면 49 처럼 N^2 이 출력되는 버그가 있었습니다..
한 5분 눈이 빠져라 검사해보니 조건문에 조건을 하나 빼먹었더라구요..

if (!visited[y][x] && graph[y][x] >= level) { // 여기!
    visited[y][x] = true;
    bfs(graph, visited, x, y, level);
    cnt++;
}

저것을 고치니 정답이었습니다!

저도 코드가 더러운 느낌이 있어서 정리한번 싹 해줬습니다.
그리고 근호님 코드와 유사합니다.
피드백 요구하셨는데 제 눈에는 잘 짜여진 코드 같아요!

#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;

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

void bfs(vector<vector<int>>& graph, vector<vector<bool>>& visited, int cur_x, int cur_y, int level) {
    queue<pair<int, int>> q;
    q.push({cur_x, cur_y});
    visited[cur_y][cur_x] = true;

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        for (int dir = 0; dir < 4; dir++) {
            int x_ = x + offset[dir][1];
            int y_ = y + offset[dir][0];
            if (0 <= x_ && x_ < N && 0 <= y_ && y_ < N && !visited[y_][x_] && graph[y_][x_] >= level) {
                q.push({x_, y_});
                visited[y_][x_] = true;
            }
        }
    }
}

int getSafeArea(vector<vector<int>> graph, int level) {
    vector<vector<bool>> visited(N, vector<bool>(N, false));

    int cnt = 0;
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            if (!visited[y][x] && graph[y][x] >= level) {
                visited[y][x] = true;
                bfs(graph, visited, x, y, level);
                cnt++;
            }
        }
    }

    return cnt;
}

int main() {
    cin >> N;

    vector<vector<int>> graph(N, vector<int>(N));
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            cin >> graph[y][x];
        }
    }

    int maxArea = 0;
    for (int level = 0; level <= 100; level++) {
        maxArea = max(getSafeArea(graph, level), maxArea);
    }

    cout << maxArea;

    return 0;
}

[g0rnn]

그래프 탐색은 언제나 한번에 풀리는 경우가 없네요.. 이번에는 모든 도시가 물에 잠기는 경우를 고려하지 못해 높이가 가장 낮은 지점 - 1 부터 시작해야하는데 그걸 못봐서 좀 오래 걸렸네요.

하지만 이런 유형을 많이 풀다보니 visited배열의 위치나 queue를 선언하는 위치를 적절한 곳에 바로 배치하여 여러 테스트를 빠르게 통과할 수 있었네요.

코드는 근호님과 거의 비슷합니다. 고생하셨습니다

code

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

int n, high = -1, low = 1000;
int city[105][105] = {0};
int offset[4][2] = {{1, 0},{0,1},{-1,0},{0,-1}};
bool visited[105][105] = {false};

bool canMove(int x, int y, int level) {
    return 0<=x&&x<n&&0<=y&&y<n
        && !visited[y][x] && city[y][x] > level;
}

int bfs(int level, int x, int y) {    
    queue<pair<int, int>> q;
    q.emplace(x, y);
    visited[y][x] = true;
    
    while(!q.empty()) {
        auto [cx, cy] = q.front(); q.pop();
        for(auto& dir : offset) {
            int nx = cx + dir[0];
            int ny = cy + dir[1];
            if(!canMove(nx, ny, level)) continue;
            q.emplace(nx, ny);
            visited[ny][nx] = true;
        }
    }
    return 1;
}

int main() {
    cin>>n;
    for(int y=0;y<n;y++) for(int x=0;x<n;x++) {
        cin>>city[y][x];
        if(high < city[y][x]) high = city[y][x];
        if(low > city[y][x]) low = city[y][x];
    }
    
    int maxSafe = -1;
    for(int level=low-1; level<=high; level++) {
        memset(visited, false, sizeof(visited));
        int safe = 0;
        for(int y=0;y<n;y++) for(int x=0;x<n;x++) 
            if(city[y][x] > level && !visited[y][x]) safe += bfs(level, x, y);
        if(maxSafe < safe) maxSafe = safe;
    }
    cout<<maxSafe;
    return 0;
}