23-hyeokbini

[hyeokbini]

🔗 문제 링크

골드 5
개똥벌레

✔️ 소요된 시간

1시간

✨ 수도 코드

문제 관찰

---

문제에서 물어보는 내용 자체는 정말 쉽습니다. 장애물들의 모습이 입력으로 주어지고, 가로 방향으로 쭉 진행했을 때 부수게 되는 장애물의 최소 개수와 그러한 구간의 총 개수를 구하면 됩니다.

문제는 입력 크기입니다. 동굴의 길이가 N(2 ~ 200000), 높이가 H(2 ~ 500000)으로 주어지는데, 시간 초과는 고사하고 bool형 2차원 벡터로만 받는다 해도 최악의 경우

200000 × 500000 = 100000000000(byte)

= 100GB 입니다. 따라서 2차원 벡터로 입력은 받을 수 없습니다.

여기서 일단은 1차원 자료구조로 입력을 저장해야 한다는 아이디어를 얻을 수 있습니다. 기본적인 내용이지만 자료구조의 차원이 늘어남에 따른 메모리 점유 차이는 어마어마하니 한번 짚고 넘어갔습니다.

그러면 인덱스(동굴의 가로 위치)와 길이(장애물 길이)로 1차원 배열에 저장한 후, 짝수 인덱스 / 홀수 인덱스에 맞추어 하나의 높이마다 가로 인덱스를 쭉 돌며 석순 / 종유석 연산을 따로 해준 다음 답을 갱신해가면 될 것 같지만, 이 방법 또한 O(N * H)의 시간 복잡도를 가지고, 최악의 경우 위에 적은 것처럼 천억번의 연산을 하기 때문에 사용할 수 없습니다.

결국 N 탐색과 H 탐색 둘 중 하나의 탐색 시간을 선형 시간보다도 줄여야 하는데, 다양한 방법이 있을 수 있습니다.

저는 H 탐색은 결국 구하는 출력값이 모든 H에 대해 탐색 후 값을 갱신해야 한다고 생각해서 N 탐색에 대해 이분 탐색 아이디어를 적용해 보았습니다. 이렇게 되면 복잡도가 O(log N * H)이므로 약 18 * 500000 = 900만 번 정도로, 충분히 실현 가능합니다.

실제 구현

---

예시 입력 1번을 그림으로 옮기면 다음과 같습니다.

위처럼 1,3,5 높이에서 2개의 장애물만 부순 후 통과할 수 있습니다. 하지만 이걸 위에서 언급했든 단순 반복문 시뮬레이션으로 연산하면 주어진 시간제한을 맞출 수 없습니다.

따라서 종유석 벡터와 석순 벡터 를 따로 입력받은 다음, 두 벡터를 sort한 후에 이분 탐색을 이용해 부수게 되는 장애물의 개수를 구했습니다.

각각 벡터를 sort하면 이런 모습이 됩니다. curheight에서 bottom과 top 벡터에 대해 이분 탐색을 진행해서 벡터 길이 - lower_bound의 인덱스를 구하면 해당 높이에서 부숴야 하는 장애물 개수를 구할 수 있습니다.

모든 H에 대해서 위 과정을 진행하고, 전역 변수의 best와 way값을 갱신해주는 방법을 사용했습니다.

📚 새롭게 알게된 내용

이분 탐색 자체는 알고리즘을 알아서 어렵지 않게 구현했는데, 이번 문제에서는 인덱싱에 대해 애를 먹은 부분이 많았습니다. 경계선 관련 문제가 유독 그렇듯 현재 높이 - 장애물 높이 비교도 그렇고 top 벡터는 천장 기준으로 계산해야 했기에 시행착오가 많았던 것 같습니다. 이건 경험의 문제니까 다양한 문제들을 더 접해봐야지 실력이 늘 것 같네요.

또한 이번 문제는 누적합을 통해서도 풀이가 가능하다고 합니다. 저한테 직관적으로 와 닿는 풀이는 이분탐색인 것 같은데, 추가로 읽어보셔도 좋을 것 같습니다.
누적합 풀이

[Seol-Munhyeok]

이 문제는 어이없게도 '석순'과 '종유석'이 뭔 의미인지 몰라서 조금 헤맸습니다.. '석순'은 아래에서 위로 올라오는 장애물, '종유석'은 위에서 아래로 내려오는 장애물이란 의미였습니다.

개똥벌레가 h 높이로 날아가는 경우 높이가 h 이상인 석순과 H-h+1 이상인 종유석의 수를 합하면 높이 h에서 충돌하는 장애물의 개수가 됩니다.

저 역시 직관적으로 바로 와닿는 풀이는 이분 탐색이어서 처음에는 이 방법으로 풀어보았습니다.

이분 탐색 풀이

from bisect import bisect_left

# 입력 처리
N, H = map(int, input().split())
down, up = [], []
for i in range(N):
    h = int(input())
    if i % 2 == 0:
        down.append(h)
    else:
        up.append(h)

down.sort()
up.sort()

best = int(1e9)  # 파괴해야 하는 장애물의 최솟값
way = 1  # 구간의 수
for h in range(1, H + 1):
    cnt_down = N // 2 - bisect_left(down, h)
    cnt_up = N // 2 - bisect_left(up, H - h + 1)
    cnt = cnt_down + cnt_up
    if best > cnt:
        best = cnt
        way = 1
    elif best == cnt:
        way += 1
        
print(best, way)

그런데 Python으로 제출 시 시간초과가 발생했습니다!

PyPy로 제출 시 통과했습니다.

시간 복잡도를 분석하면 $O(H \ \log \ N)$인데 H = 500000, N = 200000 을 대입하면 약 880만 정도가 나옵니다.

뭔가 이상해서 찾아봤는데 200000개의 입력을 받는데도 시간이 걸리기 때문에 일반적인 방법인 input()으로 입력을 받으면 시간 초과가 발생한다고 합니다.
파이썬에서 사용하는 빠른 입출력 방식인 sys.stdin.readline() 을 사용해서 통과했습니다.

누적합(차분 배열 트릭) 풀이

시간복잡도를 줄이기 위해 다른 풀이를 가져왔습니다.

사실 이 문제는 매번 석순과 종유석의 길이를 입력 받을 때마다 높이 1부터 높이 h까지 1을 계속 누적하는 방식으로 풀 수 있습니다. 다만 이렇게 풀 경우 시간복잡도가 $O(N^2)$가 되어서 그렇게는 풀 수 없는데 이때 사용하는 방법이 차분 배열 트릭입니다.

매번 높이 1부터 높이 h까지 충돌되는 횟수를 매번 더하는 것이 아닌, 높이 h에서 충돌되는 횟수의 변화량만을 기록한 후 누적합을 적용하면 $O(N)$으로 높이 h에서 총 충돌 개수를 구할 수 있습니다.

 import sys
input = sys.stdin.readline

N, H = map(int, input().split())

# line[i] = 높이 i에서 시작되는 충돌 변화량
line = [0] * H

for t in range(N):
    h = int(input())
    if t % 2 == 0:  # 석순(아래에서 위로 올라옴)
        line[0] += 1
        line[h] -= 1
    else:  # 종유석(위에서 아래로 내려옴)
        line[H - h] += 1

# prefix[y] = 높이 y에서 총 충돌 개수
prefix = [0] * (H + 1)
for i in range(H):
    prefix[i + 1] = prefix[i] + line[i]

prefix = prefix[1:]

best = min(prefix)
way = prefix.count(best)
print(best, way)

시간 복잡도는 $O(N + H)$ 입니다.

이런 비슷한 풀이를 쓰는 문제를 이전에 풀어본 기억이 나는데 13주차 때 풀었던 "광고 삽입" 문제에서 유사한 방식으로 푼 적이 있습니다.
#46

---

이분탐색과 누적합(차분 배열 트릭)을 사용한 여러 가지 관점을 볼 수 있는 문제였고
입출력에 관한 이슈도 다시 한 번 정리해보았습니다.
또한 시간 복잡도 위주로만 생각했는데 공간 복잡도도 꼭 고려해야한다는 점을 리마인드 했습니다.

문제 푼다고 고생하셨습니다!!

[mj010504]

저도 일단 박치기로 처음 시간초과를 받았습니다.(박치기 하는 습관을 줄여야할 것 같습니다.) 시간초과를 최대한 피할려 했는데 잘 생각해보니 O(n x h) 가 나오더군요. 그래서 풀이를 살짝 참고했습니다.
저는 이분탐색이 로직 짜기가 더 어려운 느낌이라서 누적합으로 풀어봤습니다! 장애물의 높이가 중요하지, 장애물의 배치 순서는 중요하지 않은 문제였네요.
히스토그램 문제와 비슷한 느낌이 있는데 히스토그램 문제는 순서도 고려해야 하므로 스택으로 풀었던 것 같네요.
수고하셨습니다!

개똥벌레

#include <bits/stdc++.h>

using namespace std;

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

int main() {
   // freopen("input.txt", "rt", stdin);  
    ios::sync_with_stdio(false);  
    cin.tie(0);
    cout.tie(0);
    
    int n, h; cin >> n >> h;
   
    vector<int> a(h, 0); // 석순
    vector<int> b(h, 0); // 종유석
    for(int i = 0; i < n; i++) {
        int size; cin >> size;

        if(i % 2 == 0) {
           a[size - 1]++;
        }
        else {
           b[size - 1]++;
        }
    }

    vector<int> wall(h, 0);

   
    for(int i = h - 2; i >= 0; i--) {
        a[i] += a[i + 1];
    }

   for(int i = h - 2; i >= 0; i--) {
        b[i] += b[i + 1];
    }

    int minn = INT_MAX;
    int cnt = 1;
    for(int i = 0; i < h; i++) {
        wall[i] = a[i] + b[h - 1 -i];
        if(minn > wall[i]) {
            cnt = 1;
            minn = wall[i];
        }
        else if(minn == wall[i]) {
            cnt++;
        }
    }
   
    cout << minn << " " << cnt;
    

    return 0;
}

[flydongwoo]

석순과 종유석을 높이별로 세어 누적합을 만든 뒤, 각 비행 높이마다 부딪히는 장애물 수를 O(N+H)로 계산해 최소 충돌값과 그 빈도를 구하는 알고리즘으로 풀어봤습니다.

개똥벌레

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, H;
    cin >> N >> H;

    vector<int> downCount(H + 2, 0);
    vector<int> upCount(H + 2, 0);

    for (int i = 0; i < N; i++) {
        int x;
        cin >> x;
        if (i % 2 == 0) {
            downCount[x]++;
        } else {
            upCount[x]++;
        }
    }

    vector<int> down_acc(H + 2, 0);
    vector<int> up_acc(H + 2, 0);

    long long sum = 0;
    for (int h = H; h >= 1; h--) {
        sum += downCount[h];
        down_acc[h] = sum;
    }

    sum = 0;
    for (int u = H; u >= 1; u--) {
        sum += upCount[u];
        up_acc[H - u + 1] = sum;
    }

    long long best = LLONG_MAX;
    int bestCount = 0;

    for (int h = 1; h <= H; h++) {
        long long collide = (long long)down_acc[h] + (long long)up_acc[h];
        if (collide < best) {
            best = collide;
            bestCount = 1;
        } else {
            if (collide == best) {
                bestCount++;
            }
        }
    }

    cout << best << " " << bestCount << "\n";
    return 0;
}

문제 푸느라 고생하셨습니다