32-kokeunho

[kokeunho]

🔗 문제 링크

석유 시추 https://school.programmers.co.kr/learn/courses/30/lessons/250136

✔️ 소요된 시간

50min

✨ 수도 코드

pccp 기출 풀어보고 있는데
어쩌다보니 3연속 그래프 탐색 문제를 올리게 됐네요.
다음번에는 다른 유형에 좀 더 난이도 있는 문제를 올려보겠습니다...

시추관을 꽂을 열을 찾기 위해서 모든 열은 탐색해보아야 합니다.
처음에는 각 열을 탐색할 때마다 visited를 초기화하고 석유가 있는 칸을 만나면
bfs로 석유 영역의 크기를 구하여 열에서 얻을 수 있는 석유에 더하였습니다.
이렇게 하면 동일한 열에서는 동일한 영역에 대해 bfs를 중복 실행하지 않을 것입니다.
이렇게 구현하면 최악의 경우 O(500^4) 시간복잡도를 갖게 됩니다.
일반 테스트는 다 통과하는데 효율성 테스트는 다 떨어졌습니다.
사실 O(500^3)으로 착각해서 간당간당하긴 해도 통과되지 않나 싶었습니다;

효율성 테스트를 통과하기 위해 다음과 같이 고쳤습니다.
visited[][]를 각 열마다 초기화하지 않을 것.
각 열마다 걸치는 석유 영역의 크기를 저장한 배열 sumAreaPerCol[]을 만들고
bfs를 실행했을 때, 석유 영역의 크기를 찾고 걸치는 열 i에 대해 석유 영역을 더해주었습니다.

그리고 탐색이 끝나면
sumAreaPerCol에서 가장 큰 값을 반환합니다.

📚 새롭게 알게된 내용

[kangrae-jo]

저는 이 문제를 3번째 풀어보는 중입니다.
배울게 많은 문제였던것 같아요.

저도 처음에는 매번 bfs를 하며 visited초기화 시켰습니다.
그랬더니 시간초과가 나서 효율성테스트를 통과하지 못하더군요.

그래서 저도 근호님과 같은 방법을 찾아서 풀었던것 같네요.

한가지 다른 점이라면, 저는 set을 사용해서 석유 시추의 열을파악하지 않았습니다.
min ~ max를 설정해서 그 범위를 지정해서 풀었어요.

set의 단점이라면 자료구조의 사용으로 메모리 사용량이 늘어난다는 것이고,
max의 단점은 매번 max값을 비교하는 비용이 든다는 것이겠죠.
(hash set은 add() 속도가 O(1)이니 무시)

큰 차이는 없어보여서 입맛에 맞게 구현하면 되겠네요.
좋은 문제 감사합니다.

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

using namespace std;

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

int N, M;
vector<int> result;

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

void bfs(vector<vector<int>>& land, vector<vector<bool>>& visited, int a, int b){
    queue<pair<int, int>> q;
    q.push({a, b});
    visited[b][a] = true;
    
    int minX = a;
    int maxX = a;
    
    int cnt = 1;
    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 (isIn(y_, x_) && !visited[y_][x_] && land[y_][x_] == OIL){
                q.push({x_,y_});
                visited[y_][x_] = true;
                cnt++;
                maxX = max(maxX, x_);
            }
        }
    }
    
    for (int i = minX; i <= maxX; i++) result[i] += cnt;
}

int solution(vector<vector<int>> land) {
    N = land.size();
    M = land[0].size();
    
    vector<vector<bool>> visited(N, vector<bool> (M, false));
    result = vector<int> (M, 0);
    for (int x = 0; x < M; x++){
        for (int y = 0; y < N; y++){
            if (!visited[y][x] && land[y][x] != EMPTY) 
                bfs(land, visited, x, y);
        }
    }
    
    return *max_element(result.begin(), result.end());
}

[g0rnn]

예전에 풀어본적 있는 PCCP 기출이네요. 문제를 몇번 본적 있어서 솔루션을 생각하는 것과 구현은 쉬웠습니다.

근본적으로 석유의 위치를 파악하기 위해선 이중 for문으로 모든 칸을 탐색해야만 했고,

최대한 효율적으로 동작하기 위해 석유가 없는 곳이나 이미 방문한 적있는 석유(칸)은 제외하였습니다.

저도 근호님 처럼 Set를 사용해서 탐색한 열을 저장하였고, 석유의 크기를 더해주었습니다.

+) 열의 최댓값과 최솟값으로 방문한 열을 파악하는 것은 생각치 못했는데 좋아보이네요:)

import java.util.*;

class Solution {
    
    static int[][] offset = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 동 남 서 북
    static int[] cols;
    static boolean[][] visited;
    
    public int solution(int[][] land) {
        int n = land.length; // row
        int m = land[0].length; // col
        cols = new int[m];
        visited = new boolean[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 석유를 뽑고 cols에 저장함.
                extract(j, i, land); // x, y
            }
        }
        
        int answer = 0;
        for (int i = 0; i < m; i++) {
            if (answer < cols[i]) answer = cols[i];
        }
        return answer;
    }
    
    private static void extract(int x, int y, int[][] land) {
        if (visited[y][x]) return;
        if (land[y][x] == 0) return;
        
        Set<Integer> visitedCols = new HashSet<>();
        Queue<int[]> q = new ArrayDeque<>();
        int n = land.length;
        int m = land[0].length;
        int count = 1;
        
        visited[y][x] = true;
        q.add(new int[]{x, y});
        visitedCols.add(x);
        
        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 >= m || ny < 0 || ny >= n || visited[ny][nx]) continue;
                if (land[ny][nx] == 0) continue;
                
                q.offer(new int[]{nx, ny});
                visited[ny][nx] = true;
                visitedCols.add(nx);
                count += 1;
            }
        }
        for (Integer i : visitedCols) {
            cols[i] += count;
        }
    }
}

[wnsmir]

이 문제 오랜만에 보니 반갑군요!
처음에 풀떄 너무쉬웠는데 시간초과나서 BFS를 얼마나 최소로 쓸 수 있을지 고민했던 문제였습니다.

그기억만 가지고 다시 풀어보았습니다.

모든블록을 기준으로 BFS를 수행해야함은 변함이 없겠더라구요
따라서 0이 아닌 블록에서 BFS를 실행해주었고, 각 반복마다 1부터시작하는 라벨을 붙여주었습니다.
붙인게아니라 land에 그대로 라벨을 박아주었습니다.

이유는 나중에 열단위로 계산할떄 미리 인덱스별로 정해둔 전체 크기값을 더해주기만 하기 위함입니다.

즉 BFS는 덩어리 개수만큼만 실행되게 됩니다.
그리고 답을 구할때는 각 열에서 중복을 제거한 인덱스만 추출하여 그 인덱스 덩어리의 값만 누적합해주고 가장큰 값을 가진 인덱스를 return해주었습니다.

from collections import deque

def solution(land):
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    
    queue = deque()
    n = len(land)
    m = len(land[0])
    
    visited = [[False]*m for _ in range(n)]
    
    col_oil = [0]*m
    
    for x in range(n):
        for y in range(m):
            if land[x][y] == 1 and not visited[x][y]:
                start = (x, y)
                queue.append(start)
                count = 1
                visited[x][y] = True
                col = set()
                col.add(y)
                
                while queue:
                    curr_x, curr_y = queue.popleft()
                    for i in range(4):
                        nx = curr_x + dx[i]
                        ny = curr_y + dy[i]
                        if 0 <= nx < n and 0 <= ny < m and land[nx][ny] == 1 and not visited[nx][ny]:
                            queue.append((nx, ny))
                            visited[nx][ny] = True
                            count += 1
                            col.add(ny)
                for c in col:
                    col_oil[c] += count
                    
    return max(col_oil)