8-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ](인구 이동)https://www.acmicpc.net/problem/16234

✔️ 소요된 시간

2h

✨ 수도 코드

1.인구 이동이 일어나지 않을 때까지 방문하지 않은 위치에서 2~4번을 수행합니다.
2.bfs에서는 현재 위치로부터 상, 하, 좌, 우 연합을 형성하는지 확인합니다.
3.연합이 생성되면 연합에 속하는 나라들에 방문한 것을 표시하고  인구의 합을 return합니다.
4.return으로 받은 총 인구 수가 0 이상이면 인구 이동이 있었다고 표시하고 총 인구 수를 연합에 속하는 나라들의 수로 나누어 분배합니다.
5.인구 이동이 있을 경우에는 day_count를 1만큼 증가시키고, 
인구 이동이 없을 경우에는 반복을 종료합니다.

📚 새롭게 알게된 내용

알고리즘 스터디하면서 많이 본 BFS인데 이번에도 검색하며 풀었습니다...
비슷한 유형을 계속 풀어봐야겠습니다.

for(int[] country : union)

이렇게 낯설게 생긴 for문을 이번에 알게 되었는데,
요긴하게 쓸 수 있을 것 같습니다.
union 리스트의 각 요소는 행 열로 이루어져있는데
이를 country[0] (행), country[1] (열)에 각각 나누어 담는 것입니다.

[kangrae-jo]

문제를 해결하는 방식과 방향은 생각보다 빠르게 정했었습니다.
근데 그 생각이 구현 가능한 생각인지 의문을 품은채로 일단 구현했었습니다.

2차원 visited배열을 하나씩 살펴보면서 방문되지 않은 곳이있다면,
해당 좌표와 동일한 국가로부터 bfs를 시작하고,
bfs가 진행된 국가들에대해서 인구이동을 하고,
bfs에서 인구이동이 일어났다면, 다음날에도 동일하게 진행했습니다.

이런 로직들 사이에 얽힌 bool 변수들을 컨트롤하는데 시간을 좀 많이 썻습니다.
(이런 복잡한 로직을 설명하는 것이 좀 어렵네요... pr이나 리뷰를 하면서 설명하는 능력도 많이 길러야겠어요)

그렇게 1시간 정도 소모해서 구현을 완료하고보니.....
제 코드가 엄청엄청 나이브한 느낌이 있는겁니다.

그래서 깔끔한 코드는 포기하자... 하고 근호님 코드를 봤는데
근호님 코드랑 제 코드가 완전 비슷하네요.

그리고 다른 사람들의 코드를 검색해봤는데,
조금씩은 차이가 있지만 역시 복잡한 로직으로 구현해놨더군요.
이 문제는 원래 그런 문제인 것 같네요.

CPP CODE

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

using namespace std;

int N, L, R;
int offset[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
vector<vector<int>> A;
vector<vector<bool>> visited;

bool canOpen(int x, int y) {
    return 0 <= x && x < N && 0 <= y && y < N && !visited[y][x];
}

bool bfs(vector<vector<bool>>& visited, int x, int y) {
    bool isMoved = false;

    int people = 0;
    int country = 0;
    queue<pair<int, int>> q, updates;

    q.push({y, x});
    updates.push({y, x});

    visited[y][x] = true;
    people += A[y][x];
    country++;

    while (!q.empty()) {
        int cy = q.front().first;
        int cx = q.front().second;
        q.pop();

        for (int dir = 0; dir < 4; dir++) {
            int ny = cy + offset[dir][0];
            int nx = cx + offset[dir][1];

            if (canOpen(nx, ny)) {
                int diff = abs(A[cy][cx] - A[ny][nx]);
                if (L <= diff && diff <= R) {
                    isMoved = true;
                    visited[ny][nx] = true;
                    q.push({ny, nx});
                    updates.push({ny, nx});

                    people += A[ny][nx];
                    country++;
                }
            }
        }
    }

    int newPeople = people / country;
    while (!updates.empty()) {
        int cy = updates.front().first;
        int cx = updates.front().second;
        updates.pop();

        A[cy][cx] = newPeople;
    }

    return isMoved;
}

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

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

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

    cout << solution(0);

    return 0;
}

[g0rnn]

구현이 진짜 어렵네요.. 수도코드는 빠르게 완성했지만 구현은 답 봐도 어렵더군요

하루가 지나면 새로운 visited를 사용해야하기 때문에 전역번수로 선언하고 while문 내부에서 매번 새로운 객체를 생성하는 방법을 알 수 있었네요! 그리고 bfs는 정말 다양한 곳에서 활용할 수 있다는 것을 알 수 있었어요. 좋은 문제 감사합니당;)

code

//하나의 연합을 생성
bool bfs(int x, int y, vector<vector<bool>>& visited) {
	int sum = world[y][x];
	queue<pair<int, int>> uni, tmp;
	uni.push({ x, y });	tmp.push({ x, y });

	visited[y][x] = true;
	while (!uni.empty()) {
		int cx = uni.front().first;
		int cy = uni.front().second;
		uni.pop();

		for (int dir = 0; dir < 4; dir++) {
			int nx = cx + offset[dir][0];
			int ny = cy + offset[dir][1];

			if (0 <= nx && nx < n && 0 <= ny && ny < n && !visited[ny][nx]) {
				int diff = abs(world[cy][cx] - world[ny][nx]);
				if (l <= diff && diff <= r) {
					visited[ny][nx] = true;
					uni.push({ nx, ny }); tmp.push({ nx, ny });
					sum += world[ny][nx];
				}
			}
		}
	}

	//연합을 생성하지 못한 경우
	if (tmp.size() == 1) return false;

	//인구 이동
	int newPop = sum / tmp.size();
	while (!tmp.empty()) {
		int x = tmp.front().first;
		int y = tmp.front().second;
		tmp.pop();
		world[y][x] = newPop;
	}
	return true;
}

[wnsmir]

그래프 문제는 BFS를 사용할것인지 BFS를 사용할것인지 결정하는것이 중요하다고 생각합니다.

이 문제에서는 국경선이 열리는 모든 나라를 동시에 탐색할 수 있는 BFS가 적절하다고 판단했습니다.

시작할 국가를 (0,0)에 추가하고, 인접한 나라 중 조건을 만족하면, 큐에 추가하고 한번 전부 탐색할때까지 하루이며 더이상 안될때까지 반복하는 로직으로 구현하였습니다.

정리하자면,

BFS로 하루동안 연합을 탐색하며 조건을 만족하는 연합을 형성한다.
조건이 맞는 나라들 끼리 연합을 만들고, 인구를 재분배한다.
하루가 지나도 연합이 만들어지지 않으면 while문을 종료하고 day를 출력한다.

요즘 그래프문제 잘 안풀어보고 있었는데 훅 들어와서 시간이 좀 걸렸습니다 ㅎ,,

from collections import deque

n, l, r = map(int, input().split())

graph = []
for i in range(n):
    graph.append(list(map(int, input().split())))

# BFS 탐색 함수
def bfs(x, y, n, l, r, graph, visited):
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]  # 상하좌우 이동
    queue = deque([(x, y)])
    union = [(x, y)]
    population_sum = graph[x][y]
    visited[x][y] = True

    while queue:
        cx, cy = queue.popleft()
        for dx, dy in directions:
            nx, ny = cx + dx, cy + dy
            if 0 <= nx < n and 0 <= ny < n and not visited[nx][ny]:
                if l <= abs(graph[cx][cy] - graph[nx][ny]) <= r:
                    visited[nx][ny] = True
                    queue.append((nx, ny))
                    union.append((nx, ny))
                    population_sum += graph[nx][ny]

    return union, population_sum

# 인구 이동 처리 함수
def human_move(n, l, r, graph):
    days = 0

    while True:
        visited = [[False] * n for _ in range(n)]
        movement = False

        for i in range(n):
            for j in range(n):
                if not visited[i][j]:
                    # 연합 찾기
                    union, total_population = bfs(i, j, n, l, r, graph, visited)
                    if len(union) > 1:  # 연합이 형성된 경우
                        movement = True
                        new_population = total_population // len(union)
                        for ux, uy in union:
                            graph[ux][uy] = new_population

        if not movement:
            break
        days += 1

    return days

print(human_move(n, l, r, graph))