30-g0rnn

[g0rnn]

🔗 문제 링크

커피솝2

✔️ 소요된 시간

1h

✨ 수도 코드

30분 생각하다가 시간초과를 해결할 수 없어서 그냥 답지 봤습니다.

제가 처음 생각했던건 누적합을 사용한 방법으로, 바뀌어야할 (idx, val)를 리스트에 담고 정답을 계산할 때 차감하는 방식으로 구현하려했습니다.

nums = [1, 2, 3, 4, 5]
prefixSum = [1, 3, 6, 10, 15]
while :
    #print
    long ans = prefixSum[y-1] - prefixSum[x-2]
    idx, val = queue.pop()
    if x <= idx <= y: 
        ans - (nums[idx] - val)
    print(ans)

    #change
    queue.add({a, b})

어떤 원소가 3 -> 1이 되면 구간합은 -2가 감소하는거니 문제 없다고 생각했습니다. 하지만 시간 초과가 날겁니다. 이것도 O(N^2)이니까요. 굳이 따지자면 N(N-1) / 2이긴 하지만 아무튼 통과하진 못합니다.

이 문제를 풀기 위해선 세그먼트 트리를 이해해야 합니다. 예전에 한번 풀어봤던거 같은데 제대로 공부하지 않아 다 까먹었습니다 ^^;

세그먼트 트리란 구간합을 트리형식으로 저장한 자료구조를 말합니다. 구간합을 빠르게 계산해야할 때 주로 사용됩니다. 구성은 다음과 같습니다.

• 리프노드 : 배열의 그 수 자체
• 리프가 아닌 노드 : 왼쪽과 오른쪽 자식의 합을 저장

리프가 아닌 노드에서 왼쪽과 오른쪽 자식의 합을 저장하기에 구간 합이 완성되는 겁니다.

구간합을 캐싱해둔 트리라고 이해하면 됩니다. 이 트리를 저장하기 위해선 배열을 사용합니다. Segment Tree는 Full Binary Tree이고 가장 깊은 노드와 가장 깊지 않은 노드의 깊이 차이는 1보다 작거나 같기 때문입니다.

저는 tree = [0] * (4 * n)로 4배했는데 이러면 여유로운 배열크기라 하네요(gpt).

좀 더 정확한 size를 원한다면 2^(h+1) - 1을 구하시면 됩니다. 높이는

구간합은 어떻게 구할까요? 이건 잘 설명된 글을 첨부하겠습니당.. 세그먼트 트리와 구현에 대해 잘 설명해두었더라구요.
여기 글에서 start와 end는 node에 저장된 값의 범위입니다. (ex. 0~2 구간합 => start = 0, end = 2) 헷갈리지 마세요 (저처럼)

BOJ 세그먼트 트리

📚 새롭게 알게된 내용

[kangrae-jo]

저도 처음에 균호님 같은 생각을 했는데, 3초동안 저는 제가 천재인줄 알았습니다.
1 ~ i 의 구간합을 미리 구해놓는 방식과,
값 변경을 각 인덱스에 적용하는 것은 시간초과가 안날 수가 없는 것 같네요.

그래서 20분 고민하다가 세그먼트 트리를 공부하고 오기로 마음먹었습니다.

배열에서 트리를 구현하는 방식은 너무 오랜만이라 살짝 힘들었네요.
이해는 되는데,, 코드 짜기가 좀 힘든,,

그치만 마지막에 남겨주신 BOJ 에서 제공하는 자료가 매우 도움이 되었습니다.
동작을 그림으로 표현해줘서 감을 잘 잡을 수 있었습니다.

아예 풀이법을 몰랐어서 그런가 개어려웠네요.
감사합니다.

다음에 나오면 맞춰보도록하겠습니다.

풀이는 동일합니다.

#include <iostream>
#include <vector>

using namespace std;

vector<long long> nums;
vector<long long> tree;

long long makeTree(int start, int end, int node) {
    if (start == end) return tree[node] = nums[start];

    int mid = (start + end) / 2;
    return tree[node] = makeTree(start, mid, node * 2) +
                        makeTree(mid + 1, end, node * 2 + 1);
}

long long solution(int start, int end, int left, int right, int node) {
    if (end < left || right < start) return 0;
    if (left <= start && end <= right) return tree[node];

    int mid = (start + end) / 2;
    return solution(start, mid, left, right, node * 2) +
           solution(mid + 1, end, left, right, node * 2 + 1);
}

void updateTree(int start, int end, int node, int index, long long diff) {
    if (index < start || index > end) return;
    
    tree[node] += diff;
    if (start == end) return;

    int mid = (start + end) / 2;
    updateTree(start, mid, node * 2, index, diff);
    updateTree(mid + 1, end, node * 2 + 1, index, diff);
}

int main() {
    ios_base::sync_with_stdio(0);
    cout.tie(0);
    cin.tie(0);

    int N, Q;
    cin >> N >> Q;

    nums.assign(N + 1, 0);
    tree.assign(4 * (N + 1), 0);

    for (int i = 1; i <= N; i++) {
        cin >> nums[i];
    }

    makeTree(1, N, 1);

    while (Q--) {
        int x, y, a, b;
        cin >> x >> y >> a >> b;
        if (x > y) swap(x, y);

        cout << solution(1, N, x, y, 1) << '\n';

        long long diff = b - nums[a];
        updateTree(1, N, 1, a, diff);
        nums[a] = b;
    }

    return 0;
}

[9kyo-hwang]

전 세그먼트 트리가 싫습니다 ㅎ 얘랑 이거 비슷한 펜윅 트리 등등도...

그런데 기업 코테에는 비슷한 유형이 한 번씩 나옵니다. 대표적인게 2022년 카카오 블라인드 채용 코딩테스트 6번 문제 파괴되지 않은 건물 죠. 물론 출력은 맨 마지막에 한 번만 요구하기 때문에 세그먼트 트리를 쓸 필요는 없이 누적합을 쓰면 되죠. 하지만 이 기법을 안다면 바로 쓱쓱 써버리면 되긴 합니다.

하지만 전 여전히 너무나 싫기 때문에, Sqrt Decomposition 기법을 사용했습니다. 사실 예전에 세그먼트 트리 대표 문제인 구간 합 구하기 이거 풀 때 짰던 코드인데 문제가 똑같아서 그냥 복붙 했습니다 ㅎ... 대신 예전에 푼 건 세그먼트 트리랑 속도가 비슷했는데 이번에는 얘가 확실히 느리네요. 역시 $\sqrt{N}$이 log(N)보다 느릴 수 밖에 없군요...

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

using namespace std;
using int64 = long long;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, Q; cin >> N >> Q;
    vector<int64> Sequence(N);
    for(int64& Num : Sequence) cin >> Num;
     
    int BlockSize = static_cast<int>(ceil(sqrt(N)));
    int BlockCount = static_cast<int>(ceil(N / static_cast<float>(BlockSize)));
    vector<int64> BlockSum(BlockCount, 0);
    for(int i = 0; i < N; ++i)
    {
        BlockSum[i / BlockSize] += Sequence[i];
    }

    while(Q--)
    {
        int64 x, y, a, b; cin >> x >> y >> a >> b;
        if(x > y) swap(x, y);
        --x; --y; --a;
        
        int64 Sum = 0;
        int Begin = x / BlockSize;
        int End = y / BlockSize;
        
        for(int i = Begin; i <= End; ++i)
        {
            Sum += BlockSum[i];
        }
        
        for(int i = Begin * BlockSize; i < x; ++i)
        {
            Sum -= Sequence[i];
        }
        
        for(int i = y + 1; i < min(N, (End + 1) * BlockSize); ++i)
        {
            Sum -= Sequence[i];
        }
        
        cout << Sum << "\n";
        
        int64 Prev = Sequence[a];
        Sequence[a] = b;
        
        int64 Diff = Prev - b;
        BlockSum[a / BlockSize] -= Diff;
    }

    return 0;
}

[kokeunho]

심상치 않은 입력 범위에 솔직히 얼마 고민도 안했습니다 ㅎ..

세그먼트 트리라는 자료구조를 덕분에 공부해볼 수 있었습니다.
첨부해주신 세그먼트 트리 설명 링크가 이해하는데 큰 도움이 됐습니다!
유익한 문제 감사합니다
수고하셨습니다~

Details

import java.util.*;

public class Main {
    static int N, Q;
    static long[] tree;
    static int size;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();
        Q = sc.nextInt();

        long[] arr = new long[N+1];
        for (int i = 1; i <= N; i++) {
            arr[i] = sc.nextLong();
        }

        int h = (int)Math.ceil(Math.log(N) / Math.log(2));
        size = 1 << (h+1);
        tree = new long[size];
        init(arr, 1, N, 1);

        for (int i = 0; i < Q; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int a = sc.nextInt();
            long b = sc.nextLong();

            int left = Math.min(x, y);
            int right = Math.max(x, y);
            
            System.out.println(query(1, N, left, right, 1));
            update(1, N, a, b, 1);
        }
    }
    static void init(long[] arr, int start, int end, int node) {
        if (start == end) {
            tree[node] = arr[start];
        } else {
            init(arr, start, (start+end)/2, 2*node);
            init(arr, (start+end)/2+1, end, 2*node+1);
            tree[node] = tree[2*node] + tree[2*node+1];
        }
    }
    static long query(int start, int end, int left, int right, int node) {
        if (left > end || right < start) return 0;
        if (left <= start && end <= right) return tree[node];
        long lsum = query(start, (start+end)/2, left, right, 2*node);
        long rsum = query((start+end)/2+1, end, left, right, 2*node+1);
        return lsum + rsum;
    }
    static void update(int start, int end, int index, long value, int node) {
        if (index < start || index > end) return;
        if (start == end) {
            tree[node] = value;
            return;
        }
        update(start, (start+end)/2, index, value, 2*node);
        update((start+end)/2+1, end, index, value, 2*node+1);
        tree[node] = tree[2*node] + tree[2*node+1];
    }
}

[wnsmir]

굉장한 문제네요
세그먼트트리라는걸 처음알았습니다.

안그래도 트리가 약한데,,
구간의 합을 저장하고, 자식들은 절반의 트리에 해당하는 구간합들을 저장해두면
결국 리프노드들은 인덱스에 맞게 정수가될꺼고,
구간합을 구할때도, 인덱스의 원소를 바꿀때도 결국 트리가 업데이트되는데 까지는 트리의 높이 즉 logN만큼의 시간이 소요되기 떄문에 통과되었습니다.

좋은알고리즘하나 알아갑니다~

N, Q = map(int, input().split())
arr = list(map(int, input().split()))

size = 1
while size < N:
    size <<= 1

tree = [0] * (2 * size)
for i in range(N):
    tree[size + i] = arr[i]

for i in range(size - 1, 0, -1):
    tree[i] = tree[2 * i] + tree[2 * i + 1]

def range_query(l, r):
    l += size
    r += size
    s = 0
    while l <= r:
        if l & 1:
            s += tree[l]
            l += 1
        if not (r & 1):
            s += tree[r]
            r -= 1
        l //= 2
        r //= 2

    return s

def point_update(pos, val):
    i = size + pos
    tree[i] = val
    i //= 2
    while i:
        tree[i] = tree[2 * i] + tree[2 * i + 1]
        i //= 2

out = []
for _ in range(Q):
    x, y, a, b = map(int, input().split())
    if x > y:
        x, y = y, x
    out.append(str(range_query(x - 1, y - 1)))
    point_update(a - 1, b)

print("\n".join(out))

[wnsmir]

전 세그먼트 트리가 싫습니다 ㅎ 얘랑 이거 비슷한 펜윅 트리 등등도...

그런데 기업 코테에는 비슷한 유형이 한 번씩 나옵니다. 대표적인게 2022년 카카오 블라인드 채용 코딩테스트 6번 문제 파괴되지 않은 건물 죠. 물론 출력은 맨 마지막에 한 번만 요구하기 때문에 세그먼트 트리를 쓸 필요는 없이 누적합을 쓰면 되죠. 하지만 이 기법을 안다면 바로 쓱쓱 써버리면 되긴 합니다.

역시 모든문제를 섭렵하셨군요..
복습겸 내일 풀어보겠습니다