33-wnsmir

[wnsmir]

🔗 문제 링크

https://www.acmicpc.net/problem/16234

✔️ 소요된 시간

25min

✨ 수도 코드

오랜만에 쉬운 구현문제 들고왔습니다.

이 문제의 핵심은 붙어있는 국가들의 국경을 여는것을 어떻게 표현할 것인가 입니다.
저는 제일처음 떠올린게 bfs였습니다. 상하좌우를 탐색하는데 그만한게 없기 떄문이죠.

그러나 기존 BFS의 그리드범위와 visited조건 이외에 차이의 절대값이 R과 L사이의 값 안에 들어오는것만 queue에 append하고 visited에 추가해주는 방식으로 구현했습니다.

이후 추가하면서 해당 반복턴에 BFS덩어리에 들어가는 모든 좌표들을 따로 리스트에 추가해주고, 해당 턴이 끝날때 그 블록들의 평균값으로
land(원래 좌표)를 업데이트해주고 다음턴으로 넘어갑니다.

매턴 i, j 를 모두 bfs를 돌게 시켰더니 80%에 시간초과가 나서 반복문 시작에 visited[i][j]가 True면 continue되도록 바꿔 통과했습니다.

오랜만에 손풀고 가십시요!

from collections import deque

N, L, R = map(int, input().split())

# 지도 받기
land = [list(map(int, input().split())) for _ in range(N)]
move = False
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
day = 0

while True:
    day += 1
    unify = []
    visited = [[False]*N for _ in range(N)]

    for i in range(N):
        for j in range(N):
            # 이미 방문한곳이라면 pass
            if visited[i][j] == True:
                continue

            start = (i, j)
            queue = deque()
            queue.append(start)
            uni = []
            while queue:
                x, y = queue.popleft()
                for d in range(4):
                    nx = x + dx[d]
                    ny = y + dy[d]
                    if 0 <= nx < N and 0 <= ny < N:
                        if visited[nx][ny] == False:
                            # 차이가 L이상 R이하라면 추가
                            if L <= abs(land[x][y] - land[nx][ny]) <= R:
                                visited[nx][ny] = True
                                queue.append((nx, ny))
                                uni.append((nx, ny))

            # 이번턴에 생긴 덩어리들 추가
            if len(uni) > 0:
                unify.append(uni)
    
    # 인구이동이 진행되는 경우 인구이동 진행
    if len(unify) > 0:
        # 인구이동 진행
        for uni in unify:
            e_value = 0
            for x, y in uni:
                value = land[x][y] 
                e_value += value
            
            e_count = len(uni)
            population = e_value//e_count
            for u in uni:
                x, y = u
                land[x][y] = population

    # 안되는 경우 while문 종료하고 해당 일자 print
    else:
        print(day - 1)
        break

[kokeunho]

예전에 풀었던 문제였습니다.

그래서 구현은 새로 해보진 않았습니다 ㅎㅎ;
제 예전 풀이를 보기 전에 어떻게 풀지 생각해봤는데요.
풀이법은 제대로 떠올릴 수 있었습니다.

N * N 맵에 전체에서 모든 칸을 방문할 때까지 bfs를 시도합니다.
모든 칸을 방문했다면 day count를 +1 해줍니다.

bfs를 해서는 현재 칸 사방으로 연합이 될 수 있는지 확인하고
가능하다면 bfs 큐와 연합의 좌표 정보를 담는 union 리스트에 좌표를 넣습니다.
만약 연합의 size가 1이라면 0을 반환하고 1보다 크다면 연합의 총 인구수를 반환합니다.

그렇게 반환 받은 총 인구수가 0보다 크다면 연합의 size로 나누어 각 연합에 분배합니다.
0이라면 인구 이동을 멈추고 day count를 출력합니다.

한 번 푼 문제를 돌아볼 수 있었습니다.
덕분에 제 옛날 코드도 다시 되돌아볼 수 있었네요.
수고하셨습니다!

Details

import java.sql.SQLOutput;
import java.util.*;

public class Main {

    static int N, R, L;
    static int[][] map;
    static boolean[][] visited;
    static int[][] direction = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

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

        N = sc.nextInt();
        L = sc.nextInt();
        R = sc.nextInt();

        map = new int[N][N];

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

        int day_count = 0;

        while(true) {
            visited = new boolean[N][N];
            boolean moved = false;

            for(int i = 0; i < N; i++) {
                for(int j = 0; j < N; j++) {
                    if(!visited[i][j]) {
                        List<int[]> union = new ArrayList<> ();
                        int populationSum = bfs(i, j, union);
                        if(populationSum > 0) {
                            moved = true;
                            int newPopulation = populationSum / union.size();
                            for(int[] country : union) {
                                map[country[0]][country[1]] = newPopulation;
                            }
                        }
                    }
                }
            }
            if(!moved) {
                break;
            }
            day_count++;
        }

        System.out.println(day_count);
    }

    private static int bfs(int x, int y, List<int[]> union) {
        Queue<int[]> queue = new LinkedList<> ();
        queue.add(new int[]{x, y});
        union.add(new int[]{x, y});
        visited[x][y] = true;
        int populationSum = map[x][y];

        while(!queue.isEmpty()) {
            int[] now_position = queue.poll();
            int nowX = now_position[0];
            int nowY = now_position[1];

            for(int[] dir : direction) {
                int nx = nowX + dir[0];
                int ny = nowY + dir[1];

                if(nx >= 0 && nx < N && ny >= 0 && ny < N && !visited[nx][ny]) {
                    int diff = Math.abs(map[nowX][nowY] - map[nx][ny]);
                    if(diff >= L && diff <= R) {
                        visited[nx][ny] = true;
                        queue.add(new int[]{nx, ny});
                        union.add(new int[]{nx, ny});
                        populationSum += map[nx][ny];
                    }
                }
            }
        }
        return union.size() > 1 ? populationSum : 0;
    }
}

[kangrae-jo]

저도 보니까 9달전에 풀었던 문제라고 뜨더라구요.
오랜만에 다시 풀어보니까 저도 20분-25분 정도 걸리네요.
막힘없이 타이핑만 한 것 같은데... 시간이 꽤나 흐르네요.

그리고 예전엔 아마 gpt를 사용했던 것 같은데... 이제 20분대 컷 낼수있어서 기분이 좋습니다.
골드 4지만 말이죠 ㅎㅎ

좋은 문제 감사합니다.

#include <iostream>
#include <queue>
#include <vector>
#include <cmath>

using namespace std;

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

vector<vector<int>> board;
int N, L, R;

bool isIn(int y, int x) { return 0 <= y && y < N && 0 <= x && x < N; }

bool canOpen(int a, int b) {
    int diff = abs(a - b);
    return L <= diff && diff <= R;
}

bool move(vector<vector<bool>>& visited, int sY, int sX) {
    queue<pair<int, int>> q;
    q.push({sY, sX});
    visited[sY][sX] = true;

    queue<pair<int, int>> temp;
    int people = 0;
    bool isMoved = false;

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

        people += board[y][x];
        temp.push({y, x});

        for (int dir = 0; dir < 4; dir++) {
            int y_ = y + OFFSET[dir][0];
            int x_ = x + OFFSET[dir][1];
            if (isIn(y_, x_) && !visited[y_][x_] && canOpen(board[y][x], board[y_][x_])) {
                q.push({y_, x_});
                visited[y_][x_] = true;
                isMoved = true;
            }
        }
    }

    int moved = people / temp.size();
    while (!temp.empty()) {
        auto [y, x] = temp.front();
        temp.pop();

        board[y][x] = moved;
    }

    return isMoved;
}

int main() {
    cin >> N >> L >> R;

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

    int answer = 0;
    while (true) {
        bool isMoved = false;
        vector<vector<bool>> visited(N, vector<bool>(N, false));
        for (int y = 0; y < N; y++) {
            for (int x = 0; x < N; x++) {
                if (!visited[y][x] && move(visited, y, x)) {
                    isMoved = true;
                }
            }
        }
        if (!isMoved) break;
        else answer ++;
    }

    cout << answer << '\n';

    return 0;
}

[9kyo-hwang]

2년 전에 처음 풀었을 때 556ms로 통과했었는데, 3달 전에 다시 풀었을 때 20ms로 통과했네요(어케 했지?)...

기억이 안나서 코드만 던져봅니다 허허

참고로 요거 네이버 기출로 알고 있습니다. 그래서 거의 필수 문제 중 하나죠 :)

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

using namespace std;
using FVector2 = pair<int, int>;

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

int N, L, R;
vector<vector<int>> A;
vector<vector<bool>> Visited;
queue<FVector2> PositionQ;

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

bool ShouldOpenBorderBetween(int x, int y, int nx, int ny)
{
    int PopulationDifferences = abs(A[x][y] - A[nx][ny]);
    if(L <= PopulationDifferences && PopulationDifferences <= R)
    {
        return true;
    }
    
    return false;
}

bool BFS(int StartX, int StartY)
{
    Visited[StartX][StartY] = true;
    
    queue<FVector2> Q;
    Q.emplace(StartX, StartY);
    
    vector<FVector2> OpenedCells;
    int SumPopulation = 0;
    
    bool bOpenBorder = false;
    while(!Q.empty())
    {
        const auto [x, y] = Q.front(); Q.pop();
        OpenedCells.emplace_back(x, y);
        SumPopulation += A[x][y];
        
        for(const auto& [dx, dy] : Offset)
        {
            int nx = x + dx, ny = y + dy;
            if(OutOfBound(nx, ny) || Visited[nx][ny])
            {
                continue;
            }
            
            if(ShouldOpenBorderBetween(x, y, nx, ny))
            {
                Visited[nx][ny] = true;
                Q.emplace(nx, ny);
                bOpenBorder = true;
            }
        }
    }
    
    if(!bOpenBorder)
    {
        return false;
    }
    
    int Population = SumPopulation / OpenedCells.size();
    for(const auto& [x, y] : OpenedCells)
    {
        A[x][y] = Population;
        PositionQ.emplace(x, y);
    }
    
    return true;
}

bool ShouldMigration(int x, int y)
{
    for(const auto& [dx, dy] : Offset)
    {
        int nx = x + dx, ny = y + dy;
        if(OutOfBound(nx, ny))
        {
            continue;
        }
        
        if(ShouldOpenBorderBetween(x, y, nx, ny))
        {
            return true;
        }
    }
    
    return false;
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> L >> R;
    A.resize(N, vector<int>(N));
    
    for(int i = 0; i < N; ++i)
    {
        for(int j = 0; j < N; ++j)
        {
            cin >> A[i][j];
            PositionQ.emplace(i, j);
        }
    }
    
    int Day = 0;
    while(true)
    {
        Visited.assign(N, vector<bool>(N, false));
        bool bPopulationMoved = false;
        
        for(int Repeat = PositionQ.size(); Repeat > 0; --Repeat)
        {
            const auto [x, y] = PositionQ.front(); PositionQ.pop();
            if(Visited[x][y] || !ShouldMigration(x, y))
            {
                continue;
            }
            
            if(BFS(x, y))
            {
                bPopulationMoved = true;
            }
        }
        
        if(!bPopulationMoved)
        {
            break;
        }
        
        ++Day;
    }
    
    cout << Day;

    return 0;
}

[g0rnn]

저도 예전에 풀었던 문제인데 이번엔 좀 오래 걸렸네요. 과정을 되돌아보면 맨 처음 설계할 때 인구가 이동됐는지 판단하는 것을 고려하지 않았기 때문에 이렇게 된거 같슴다..

bfs로 연합을 구성하고 flatten으로 인구 수를 맞춥니다. flatten을 수행할 때 이전과 다른 값으로 수정되는 경우 인구 이동으로 감지하고 moved 플래그를 변경시켜 인구 이동 종료를 확인합니다.

좀 더 집중해서 풀었다면 금방 풀었을것 같네요 좋은 문제 감사합니당

package beakjoon;

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

public class Sol16234 {

    static int n, l, r;
    static int[][] city;
    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());
        l = Integer.parseInt(st.nextToken());
        r = Integer.parseInt(st.nextToken());

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

        int answer = 0;
        boolean[][] visited;
        while (true) {
            // 모든 도시를 순회하며
                // 연결가능하면 연결하고
                // 인구 이동
            visited = new boolean[n][n];
            boolean isMoved = false;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (visited[i][j]) continue;
                    List<int[]> part = bfs(j, i, visited, city);
                    isMoved = isMoved | flatten(city, part);
                }
            }
            if (!isMoved) {
                break;
            }
            answer++;
        }
        System.out.println(answer);
        br.close();
    }

    private static List<int[]> bfs(int x, int y, boolean[][] visited, int[][] city) {
        List<int[]> result = new ArrayList<>();
        Queue<int[]> q = new ArrayDeque<>();
        q.add(new int[]{x, y});
        result.add(new int[]{x, y});
        visited[y][x] = true;

        while (!q.isEmpty()) {
            int cx = q.peek()[0];
            int cy = q.poll()[1];

            for (int[] o : offset) {
                int nx = cx + o[0];
                int ny = cy + o[1];

                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
                if (visited[ny][nx]) continue;
                int diff = Math.abs(city[cy][cx] - city[ny][nx]);
                if (!(l <= diff && diff <= r)) continue;
                q.add(new int[]{nx, ny});
                result.add(new int[]{nx, ny});
                visited[ny][nx] = true;
            }
        }
        return result;
    }

    private static boolean flatten(int[][] city, List<int[]> part) {
        boolean moved = false;
        int size = part.size();
        if (size == 1) return moved;

        int sum = 0;
        for (int i = 0; i < size; i++) {
            int x = part.get(i)[0];
            int y = part.get(i)[1];
            sum += city[y][x];
        }
        final int avg = sum / size;
        for (int[] p : part) {
            if (city[p[1]][p[0]] != avg) moved = true;
            city[p[1]][p[0]] = avg;
        }
        return moved;
    }
}