24-hyeokbini

[hyeokbini]

🔗 문제 링크

PCCP 기출 문제 레벨 2
석유 시추

✔️ 소요된 시간

40분

✨ 수도 코드

문제에서 요구하는 내용은 크게 어렵지 않습니다. 직관적으로 떠오르는 풀이는 한 가로 인덱스에 대해 모든 높이에서 BFS를 돌려 보고, 석유 값을 모두 더한 다음 답 최댓값을 갱신하는 로직으로 충분히 답을 구할 수 있습니다. 백준 1926 그림의 풀이와 유사하겠네요.

시행착오

---

하지만 단순하게 위 내용을 그대로 구현해서 모든 지점에서 BFS를 돌린다면, 정확성 테스트는 100점이지만 효율성 테스트에서 0점을 받습니다.

석유 시추 / 시간초과

#include <bits/stdc++.h>

using namespace std;

int ans = 0;
int row, col;
int dx[4] = {0,1,-1,0};
int dy[4] = {1,0,0,-1};

void func(vector<vector<int>> land, int rowidx)
{
    int curans = 0;
    vector<vector<bool>> visited(col,vector<bool>(row,false));
    for(int i = 0; i < col; i++)
    {
        if(land[i][rowidx] == 0)
        {
            continue;
        }
        if(visited[i][rowidx] == true)
        {
            continue;
        }
        queue<pair<int,int>> Q;
        visited[i][rowidx] = true;
        Q.push({i,rowidx});
        while(!Q.empty())
        {
            pair<int,int> cur = Q.front();
            Q.pop();
            curans++;
            for(int i = 0; i < 4; i++)
            {
                int nx = cur.first + dx[i];
                int ny = cur.second + dy[i];
                if(nx < 0 || ny < 0 || nx >= col || ny >= row)
                {
                    continue;
                }
                if(land[nx][ny] == 0)
                {
                    continue;
                }
                if(visited[nx][ny] == true)
                {
                    continue;
                }
                visited[nx][ny] = true;
                Q.push({nx,ny});
            }
        }
    }
    ans = max(curans,ans);
}

int solution(vector<vector<int>> land) {
    row = land[0].size();
    col = land.size();
    // 가로 한 인덱스마다 검사
    for(int i = 0; i < row; i++)
    {
        func(land,i);
    }
    return ans;
}

어떻게 보면 당연합니다. 한 가로 인덱스에 대해서는 visited를 사용해서 최적화를 진행한다 해도, 다음 가로 인덱스로 넘어간다면 처음부터 다시 탐색하는 비효율성이 있기 때문입니다.

따라서 어떻게든 최적화를 시켜야 하는데, 저는 살짝 애드혹..? 느낌으로 최적화를 진행했습니다.

최적화

---

문제에서 기준점으로 잡는 것은 한 가로 인덱스에 대한 모든 세로 인덱스에서 얻을 수 있는 석유 덩어리 양 입니다.

land 벡터의 가로 길이를 가지는 v 벡터를 만들어준 후, BFS를 모든 지점에 대해 1회 진행하면서 석유가 감지된다면 해당 석유 덩어리의 가로 최소 / 최대 인덱스(ymin, ymax)를 기록합니다. 그리고 BFS를 통해 얻은 석유 덩어리의 넓이를 v벡터의 ymin ~ ymax 인덱스에 누적해줍니다.

문제에서 예시로 주는 이미지인데, 위 이미지를 예시로 든다면

크기 8짜리 석유 덩어리는 0-based 인덱스의 v 벡터를 0 ~ 2 인덱스에서 8만큼 증가시킵니다.
마찬가지로 7 크기는 3 ~ 6 인덱스를 7만큼,
2 크기는 6 ~ 7 인덱스를 2만큼 증가시킵니다.

최종적으로 모든 칸에 대해 BFS를 진행한다면, v 벡터는
[8,8,8,7,7,7,9,2] 가 되고, 최댓값인 9가 answer가 됩니다.

위 방식은 한번 BFS가 진행된 석유 덩어리에 대해 다시 BFS가 진행되지 않고, 모든 칸을 한번씩만 순회하기 때문에 O(N * M) 시간 복잡도를 가집니다.

📚 새롭게 알게된 내용

직관적으로 보이는 풀이가 너무 익숙해 보여서 오히려 시행착오를 겪은 것 같네요. 구하는 값의 목적..? 에 따라 답을 기록하는 방식을 유연하게 바꿔 가며 생각할 수 있다는 관점을 배워가는 것 같습니다.

[Seol-Munhyeok]

저는 좀 아예 다른 풀이로 접근했습니다.

일단 land의 값을 BFS로 구한 각 컴포넌트의 크기로 채웁니다.
예를 들어

이 예시인 경우

12 0 3 0 2 2 
12 0 3 0 0 0 
12 0 3 0 0 1 
12 0 0 2 0 0 
12 0 0 2 0 1 
12 0 0 0 0 0 
12 12 12 12 12 12 

이런 식으로 land 배열을 갱신합니다.

그리고 직접 모든 열에 대해서 세로방향으로 탐색을 하는데 서로 다른 컴포넌트끼리만 값을 더해야하기 때문에 visited 배열을 이용해 각 컴포넌트는 서로 다른 숫자를 가지도록 comp_id를 부여했습니다. 예를 들어 위 예시의 경우

1 0 2 0 3 3 
1 0 2 0 0 0 
1 0 2 0 0 4 
1 0 0 5 0 0 
1 0 0 5 0 6 
1 0 0 0 0 0 
1 1 1 1 1 1 

이렇게 됩니다.

이렇게 했으면 세로 방향으로 모두 탐색하면서 다른 컴포넌트에 해당하는 land의 값을 모두 더하면 됩니다.

코드는 좀 장황하긴 합니다.

from collections import deque

def solution(land):
    dy, dx = [-1, 0, 1, 0], [0, 1, 0, -1]
    n, m = len(land), len(land[0])
    visited = [[0 for _ in range(m)] for _ in range(n)]
    comp_id = 0
    for i in range(n):
        for j in range(m):
            if land[i][j] != 1 or visited[i][j]:
                continue
            # 1 (석유)를 발견하면 BFS 시작
            comp_id += 1
            queue = deque([(i, j)])
            visited[i][j] = comp_id
            cells = [(i, j)]
            
            while queue:
                y, x = queue.popleft()
                for k in range(4):
                    ny, nx = y + dy[k], x + dx[k]
                    if 0 <= ny < n and 0 <= nx < m and not visited[ny][nx] and land[ny][nx] == 1:
                        queue.append((ny, nx))
                        visited[ny][nx] = comp_id
                        cells.append((ny, nx))
            # 석유 컴포넌트의 값을 컴포넌트의 크기로 수정함
            size = len(cells)
            for y, x in cells:
                land[y][x] = size

    # 모든 열에 대해서 석유의 양을 계산
    answer = -1
    for i in range(m):
        seen = set()
        temp = 0
        for j in range(n):
            cid = visited[j][i]
            if cid != 0 and cid not in seen:
                seen.add(cid)
                temp += land[j][i]
        answer = max(answer, temp)
    
    return answer

---

실수 정리

이 문제를 풀면서 한 가지 실수를 해서 시간을 잡아먹었는데

무슨 실수를 한 건지 보이시나요?

제일 위에 for 문으로 사용할 변수로 i, j를 이미 사용해 놓고 밑에서 다시 i 인덱스 변수를 사용했습니다.
이런 실수는 절대로 하면 안되겠습니다!!

문제 푼다고 수고했습니다!!!!!

[mj010504]

저는 바로 덩어리 별로 index를 붙여주어서 풀이했습니다. index를 사용하기 위해서 원래는 석유가 있을 때 1이지만 -1로 초기화해주는 작업을 처음에 했습니다. 또한 0은 석유가 없는 것을 의미하므로 index를 1부터 사용했습니다. ov라는 배열에 index별로 덩어리의 크기를 저장해뒀습니다.
이제 가로 별로 아래로 가면서 해당 값이 index라 즉, 0보다 크다면 ov[index]를 통해 해당 덩어리르 더해주고, 해당 덩어리는 방문처리하여 중복된 덩어리를 더하지 않도록 하면서 풀이했습니다.
수고하셨습니다!

석유 시추

#include<bits/stdc++.h>

using namespace std;

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

int solution(vector<vector<int>> v) {
    vector<int> ov;
    ov.push_back(0); // 불필요한 값
   int n = v.size(), m = v[0].size();
   int idx = 1;

   for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            if(v[i][j] == 1) {
                v[i][j] = -1;
            }
        }
   }

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            if(v[i][j] == -1) {
                v[i][j] = idx;
                int size = 1; // 덩어리 크기
                
                queue<pair<int, int>> q; 
                q.push({i, j});

                while(!q.empty()) {
                    auto tp = q.front(); q.pop();

                    for(int d = 0; d < 4; d++) {
                        int xx = tp.first + dx[d];
                        int yy = tp.second + dy[d];

                        if(xx >=0 && xx < n && yy >=0 && yy < m && v[xx][yy] == -1) {
                            v[xx][yy] = idx;
                            size++;
                            q.push({xx, yy});
                        }
                    }
                }
                
                ov.push_back(size);
                idx++;
            }
        }
   }

   int res = 0;
   for(int i = 0; i < m; i++) {
        vector<bool> visited(ov.size(), false);
        int sum = 0;
        for(int j = 0; j < n; j++) {
            int temp = v[j][i];
            if(temp > 0 && !visited[temp]) {
                visited[temp] = true;
                sum += ov[temp];
            }
        }

        res = max(res, sum);
   }


    return res;
}

[flydongwoo]

DFS로 석유 덩어리를 분리하고 크기와 열 범위를 구한 뒤, 배열과 prefix sum 기법으로 각 열의 석유량을 효율적으로 계산하는 풀이를 사용했습니다

석유 시추

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

int nRows, nCols;
vector<vector<int>> landMap;
vector<vector<bool>> visited;
int dx[4] = { -1, 1, 0, 0 };
int dy[4] = { 0, 0, -1, 1 };
vector<long long> colDiff;

int dfs(int x, int y, int &minCol, int &maxCol) {
    stack<pair<int,int>> st;
    st.push({x, y});
    visited[x][y] = true;
    int compSize = 0;
    while (!st.empty()) {
        auto p = st.top();
        st.pop();
        int cx = p.first;
        int cy = p.second;
        compSize++;
        if (cy < minCol) {
            minCol = cy;
        }
        if (cy > maxCol) {
            maxCol = cy;
        }
        for (int dir = 0; dir < 4; dir++) {
            int nx = cx + dx[dir];
            int ny = cy + dy[dir];
            if (nx < 0 || nx >= nRows || ny < 0 || ny >= nCols) {
                continue;
            }
            if (visited[nx][ny]) {
                continue;
            }
            if (landMap[nx][ny] == 0) {
                continue;
            }
            visited[nx][ny] = true;
            st.push({nx, ny});
        }
    }
    return compSize;
}

long long solution(vector<vector<int>> land) {
    nRows = land.size();
    nCols = land[0].size();
    landMap = land;
    visited.assign(nRows, vector<bool>(nCols, false));
    colDiff.assign(nCols + 1, 0);
    for (int i = 0; i < nRows; i++) {
        for (int j = 0; j < nCols; j++) {
            if (!visited[i][j] && landMap[i][j] == 1) {
                visited[i][j] = true;
                int minCol = j;
                int maxCol = j;
                int compSz = dfs(i, j, minCol, maxCol);
                colDiff[minCol] += compSz;
                if (maxCol + 1 < nCols) {
                    colDiff[maxCol + 1] -= compSz;
                }
            }
        }
    }
    long long ans = 0;
    long long running = 0;
    for (int col = 0; col < nCols; col++) {
        running += colDiff[col];
        if (running > ans) {
            ans = running;
        }
    }
    return ans;
}

문제 푸느라 고생하셨어유