37-Munbin-Lee

[Munbin-Lee]

🔗 문제 링크

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

✔️ 소요된 시간

1시간

✨ 수도 코드

문제 설명

열 하나를 관통하도록 시추관을 꽂는다.

시추관은 해당 열에 포함된 모든 석유 덩어리의 석유를 뽑는다.

임의의 열에 시추관을 꽂았을 때, 뽑을 수 있는 최대의 석유량은?

---

효율성 테스트 케이스 제한사항

주어진 조건 외 추가 제한사항 없습니다.

백준도 가끔 제한사항이 무엇인지 알려주지 않는데, 개인적으로는 조금 불편하다.

정말 제한사항이 없다면 입력이 1억 개 넘게 들어올 수도 있다는 건데, 실제로 그럴 리는 없으니까...

어쨌든 이 제한사항을 보고 최대한 효율적으로 구현해야겠다고 생각했다.

---

먼저, 석유 덩어리를 어떻게 체크할 지 생각했다.

BFS, DFS, 유니온파인드 정도가 생각났는데,

어차피 각 셀은 한 번씩만 방문하므로 O(land의 넓이) 라 무슨 방법을 선택하든 효율적인데

굳이 유니온파인드로 돌아갈 필요는 없다고 생각했고,

재귀를 안 쓰고 구현하는 게 깔끔할 것 같아 BFS로 체크하기로 했다.

---

각 시추관을 꽂을 때마다 BFS로 체크한다면, 이미 했던 연산을 다시 하기 때문에 비효율적이다.

그래서 전처리로 BFS를 한번만 하기로 했다.

대략적인 방법은 다음과 같다.

각 오일에 대하여 어떤 청크(덩어리)인지 번호를 매기고,

각 청크의 오일량이 얼마인지 저장하는 것이다.

이제 코드로 구현해보자.

---

vector<vector<int>> chunks(r, vector<int> (c, -1));
vector<int> oils;

chunks는 각 셀이 몇 번 청크인지를 저장한다. 석유가 아니라면 -1이다.

oils는 각 청크의 석유량을 저장한다.

---

auto bfs = [&](int y, int x, int chunk) {
	// 해당 셀의 청크와, 그 청크의 석유량을 저장한다.
};

for (int y = 0; y < r; y++) {
	for (int x = 0; x < c; x++) {
		// 방문 처리는 셀의 land 값을 0으로 만드는 방식으로 한다.
		if (land[y][x] == 0) continue;
		
		land[y][x] = 0;
		bfs(y, x, oils.size());
	}
} 

모든 셀에 대해 BFS를 돌려 chunks와 oils를 완성한다.

---

int answer = -1;

// 모든 열에 대해 시추관을 꽂은 후 최대 석유량을 구한다.
for (int x = 0; x < c; x++) {

	// 청크는 중복될 수도 있기 때문에 set을 사용한다.
	unordered_set<int> set;
	
	for (int y = 0; y < r; y++) {
		int chunk = chunks[y][x];
		
		if (chunk == -1) continue;
		
		set.emplace(chunk);
	}
	
	// 시추관이 관통한 모든 청크의 석유량을 더한다.
	int oil = 0;
	
	for (int chunk : set) {
		oil += oils[chunk];
	}
	
	answer = max(answer, oil);
}

return answer;

---

특별한 알고리즘이나 아이디어를 쓰지 않고 풀 수 있게 만든 재밌는 문제인 것 같다.

지문도 프로그래머스답지 않게 굉장히 깔끔한데 PCCP 문제라서 그런가...

다음에도 PCCP 문제를 풀어서 비교해봐야겠다.

📚 전체 코드

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

using namespace std;

int solution(vector<vector<int>> land) {
    int r = land.size();
    int c = land[0].size();
    
    int dy[4] {-1, 0, 1, 0};
    int dx[4] {0, -1, 0, 1};
    
    vector<vector<int>> chunks(r, vector<int> (c, -1));
    vector<int> oils;
    
    auto bfs = [&](int y, int x, int chunk) {
        queue<pair<int, int>> q;
        q.emplace(y, x);
        
        int oil = 0;
        
        while (!q.empty()) {
            auto [cy, cx] = q.front();
            q.pop();

            oil++;
            chunks[cy][cx] = chunk;

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

                if (ny == -1 || ny == r || nx == -1 || nx == c) continue;
                if (land[ny][nx] == 0) continue;

                land[ny][nx] = 0;
                q.emplace(ny, nx);
            }
        }
        
        oils.emplace_back(oil);
    };
    
    for (int y = 0; y < r; y++) {
        for (int x = 0; x < c; x++) {
            if (land[y][x] == 0) continue;
            
            land[y][x] = 0;
            bfs(y, x, oils.size());
        }
    }
    
    int answer = -1;
    
    for (int x = 0; x < c; x++) {
        unordered_set<int> set;
        
        for (int y = 0; y < r; y++) {
            int chunk = chunks[y][x];
            
            if (chunk == -1) continue;
            
            set.emplace(chunk);
        }
        
        int oil = 0;
        
        for (int chunk : set) {
            oil += oils[chunk];
        }
        
        answer = max(answer, oil);
    }
    
    return answer;
}

[tgyuuAn]

효율성 테스트 케이스 제한사항

주어진 조건 외 추가 제한사항 없습니다.

백준도 가끔 제한사항이 무엇인지 알려주지 않는데, 개인적으로는 조금 불편하다.

정말 제한사항이 없다면 입력이 1억 개 넘게 들어올 수도 있다는 건데, 실제로 그럴 리는 없으니까...

어쨌든 이 제한사항을 보고 최대한 효율적으로 구현해야겠다고 생각했다.

효율성 테스트에 최대 n = 500이라고 되어 있네요 !!!!!

저도 문빈님이랑 똑같이 BFS, DFS, 유니온 파인드 생각했어요.

근데 유니온 파인드는 너무 돌아가는 거라고 생각했고, DFS BFS로도 간단히 풀리겠다 생각해서 DFS로 해결 했씁니다,

문제 재밌네요 허허

from collections import defaultdict
import sys

sys.setrecursionlimit(1000000)

temp = 0
def dfs(y, x, visited, land, col_info):
    global temp

    n_y = len(land)
    n_x = len(land[0])

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

    for dir in range(4):
        new_y = y+dy[dir]
        new_x = x+dx[dir]

        if new_y < 0 or new_y >= n_y: continue
        if new_x < 0 or new_x >= n_x: continue
        if (new_y, new_x) in visited: continue
        if land[new_y][new_x] == 0: continue

        visited.add((new_y, new_x))
        col_info.add(new_x)
        temp += 1
        dfs(new_y, new_x, visited, land, col_info)

def solution(land):
    global temp

    visited = set()
    
    n_row = len(land)
    n_col = len(land[0])
    oil_info = defaultdict(int)

    for row in range(n_row):
        for col in range(n_col):
            if land[row][col] == 1 and (row, col) not in visited:
                temp = 1
                col_info = {col,}
                visited.add((row,col))
                dfs(row, col, visited, land, col_info)

                for c in col_info:
                    oil_info[c] += temp
                    
    return max(list(oil_info.values()))

land = [[0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 0, 1, 1, 0], [1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 1, 1]]
print(solution(land))

[pknujsp]

수고하셨습니다 문제 깔끔하고 좋네요

저도 BFS를 기본으로 해서 풀었어요

• land를 첫번째 행, 열에서 시작해서 오른쪽 방향으로 한 행씩 훑으면서 다음 작업을 합니다
• 훑고 있는 행과 열의 값이 1 이면 여기에서 BFS를 해서 총 시추량을 구하고
• BFS 중에 들린 열을 set에 모두 담아서 열 별로 총 시추량을 기록합니다
• 확인한 지점은 값을 0으로 바꿔서 나중에 다시 탐색하지 않게 해줍니다
• 모든 지점을 다 훑은 후에는 확인한 열 중에서 시추량이 최대값인 것을 반환합니다

from collections import *

def solution(land):
    answer = 0
    cols = [0] * len(land[0])
    dr = [1,-1,0,0]
    dc = [0,0,-1,1]
    
    for row in range(len(land)):
        for col in range(len(land[0])):
            if land[row][col] == 0:
                continue
                
            q = deque([(row, col)])        
            check_cols = set()
            t = 0
            land[row][col] = 0
            
            while q:
                r, c = q.popleft()
                check_cols.add(c)
                t += 1
                
                for i in range(4):
                    nr = r + dr[i]
                    nc = c + dc[i]
                    if not 0 <= nr < len(land) or not 0 <= nc < len(land[0]):
                        continue
                    if land[nr][nc] == 0:
                        continue
                        
                    land[nr][nc] = 0
                    q.append((nr, nc))
                    
            for c in check_cols:
                cols[c] += t
                
    return max(cols)

[H0ngJu]

오오 이거 저번학기 자료구조 때 배웠던 미로탈출 문제랑 비슷하네요
가능한 경로를 모두 탐색하는 거였는데, 그 때도 bfs로 구현했네요

그래서 bfs, dfs는 떠올릴 수 있었는데 유니온 파인드는 처음 들어보는 개념이네요 ..ㅎㅎ
덕분에 하나 또 배워갑니다. 수고하셨슴다 -!