31-g0rnn

[g0rnn]

🔗 문제 링크

음주 코딩

✔️ 소요된 시간

40m

✨ 수도 코드

어디선가 본적있는 유형이죠? 배열의 특정 구간을 곱하거나, 특정 idx의 값을 바꿔야하는 문제입니다.

저번 PR 에 올렸던 세그먼트 트리입니다. 저번 문제가 너무 세그먼트 트리만을 위한 문제 같았기에 좀 아쉬워서 다른 문제를 가져와보았습니다. 근데 이것도 좀 그런느낌이네요..ㅜ

이번에도 전체적인 구조는 같습니다. 세그먼트 트리를 만들고, update 하거나 query하는 거죠.

문제를 푸는데 약간의 팁을 드리자면 곱셈을 일일이 다 해주기 힘드니 1, 0, -1로 치환한 후 곱셈을 처리하는게 좋을 것 같습니다 :)

📚 새롭게 알게된 내용

[kangrae-jo]

발머의 피크 이론(Ballmer's Peak Theory)은 프로그래머의 혈중 알콜 농도가 0.129% 와 0.138% 사이일 때 초인적인 코딩 실력을 발휘한다는 이론이다.

저도 술 한장하고 코딩하는주입ㄴ디ㅏ.
잘 되는거 ㅅ같네요ㅕ.

장난이구요. 오늘도 재밌는 세그먼트트리 문제를 들고와주셨군요.
저번에 했던 세그먼트 구조가 아직 체화되지않아서.. 이전 문제를 조금 컨닝 했습니다.

덧셈의 항등원은 0이라는 점과 곱셈의 항등원은 1이라는 점만 주의하면서 코딩을 했습니다.
그리고 X에 들어갈 숫자들을 1,0,-1로 변경해두는 아이디어도 중요한 것 같습니다.

여전히 세그먼트는 어렵네요.
다음 문제로 나오면 진짜진짜 맞춰보겠습니다.

#include <iostream>
#include <vector>

using namespace std;

vector<int> X;
vector<int> tree;

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

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

void updateTree(int start, int end, int node, int index, int V) {
    if (index < start || index > end) return;

    if (start == end) {
        tree[node] = V;
        return;
    }

    int mid = (start + end) / 2;
    updateTree(start, mid, node * 2, index, V);
    updateTree(mid + 1, end, node * 2 + 1, index, V);
    tree[node] = tree[node * 2] * tree[node * 2 + 1];
}

int solution(int start, int end, int left, int right, int node) {
    if (end < left || right < start) return 1;
    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);
}

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

    int N, K;
    while (cin >> N >> K) {
        X.assign(N + 1, 0);
        for (int i = 1; i <= N; i++) {
            int temp;
            cin >> temp;
            if (temp == 0) X[i] = 0;
            else if (temp > 0) X[i] = 1;
            else X[i] = -1;
        }

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

        vector<char> answer;
        while (K--) {
            char command;
            cin >> command;

            if (command == 'C') {
                int i, V;
                cin >> i >> V;
                if (V > 0) V = 1;
                else if (V < 0) V = -1;
                updateTree(1, N, 1, i, V);
            } else if (command == 'P') {
                int i, j;
                cin >> i >> j;
                int temp = solution(1, N, i, j, 1);
                if (temp == 0) answer.push_back('0');
                else if (temp > 0) answer.push_back('+');
                else answer.push_back('-');
            }
        }

        for (char c : answer) cout << c;
        cout << '\n';
    }

    return 0;
}

[kangrae-jo]

저는 이거 함수화 하려다가 말았는데... 굿입니다.

[kokeunho]

너무 어렵읍니다...

저번에 세그먼트 트리 배웠긴 하지만
아직 혼자 구현은 어렵네요
그래서 아래 코드가 거의 제 코드는 아닌 수준입니다..

그리고 들어오는 명령이 C냐 P냐에 따라서
그 뒤의 값이 변경할 값인지 j(인덱스)인지로 나뉘어서
구현에서 디테일한 부분을 신경써야해서 더 어려웠습니다.

세그먼트 트리 더 연습해서 완전히 체득해야겠습니다
수고하셨습니다.

Details

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static int N, K;
    static int[] tree;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        StringBuilder sb = new StringBuilder();

        while (true) {
            line = br.readLine();
            if (line == null || line.isEmpty()) break;
            StringTokenizer st = new StringTokenizer(line);
            N = Integer.parseInt(st.nextToken());
            K = Integer.parseInt(st.nextToken());

            int[] arr = new int[N];
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < N; i++) arr[i] = Integer.parseInt(st.nextToken());

            tree = new int[4 * N];
            init(1, 0, N-1, arr);

            StringBuilder lineSb = new StringBuilder();
            for (int i = 0; i < K; i++) {
                st = new StringTokenizer(br.readLine());
                String cmd = st.nextToken();
                int a = Integer.parseInt(st.nextToken()) - 1;
                int b = Integer.parseInt(st.nextToken());

                if (cmd.equals("C")) {
                    update(1, 0, N-1, a, b);
                } else {
                    int response = query(1, 0, N-1, a, b-1);
                    if (response > 0) lineSb.append('+');
                    else if (response < 0) lineSb.append('-');
                    else lineSb.append('0');
                }
            }

            sb.append(lineSb).append("\n");
        }
        System.out.print(sb);
    }
    static void init(int node, int start, int end, int[] arr) {
        if (start == end) {
            tree[node] = Integer.compare(arr[start], 0);
        } else {
            int mid = (start + end) / 2;
            init(node*2, start, mid, arr);
            init(node*2+1, mid+1, end, arr);
            tree[node] = tree[node*2] * tree[node*2+1];
        }
    }
    static void update(int node, int start, int end, int idx, int val) {
        if (idx < start || idx > end) return;
        if (start == end) {
            tree[node] = Integer.compare(val, 0);
        } else {
            int mid = (start + end) / 2;
            update(node*2, start, mid, idx, val);
            update(node*2+1, mid+1, end, idx, val);
            tree[node] = tree[node*2] * tree[node*2+1];
        }
    }
    static int query(int node, int start, int end, int left, int right) {
        if (right < start || end < left) return 1;
        if (left <= start && end <= right) return tree[node];
        int mid = (start + end) / 2;
        return query(node*2, start, mid, left, right) * query(node*2+1, mid+1, end, left, right);
    }
}

[9kyo-hwang]

어떻게든 세그먼트 트리를 안쓰고자... 이번에도 Sqrt Decomposition 기법을 들고왔습니다. 그런데 곱 처리가 골때려서 어떻게 하지... 하다가 GPT한테 힌트 얻고 해결했네요.

실제 연산된 결과를 알 필요 없이 [0이냐 -1이냐 1이냐] 판단만 할 수 있으면 되니, 애초부터 데이터를 -1/0/1로 압축해서 들고 있도록 합니다. 또한 연산에 영향을 주는 -1과 0 개수를 들고 있도록 합니다.

inline int Comp(ll x) {
    if(x > 0) {
        return 1;
    } else if(x < 0) {
        return -1;
    } else {
        return 0;
    }
}

void Init(int& B, int& NB) {
    X.resize(N);
    
    B = max(1, (int)sqrt(N));  // 블록 크기
    NB = (N + B - 1) / B;  // 블록 개수
    
    zeroCnts.assign(NB, 0);
    negCnts.assign(NB, 0);
    
    for(int i = 0; i < N; ++i) {
        ll x; cin >> x;
        X[i] = Comp(x);
        
        int b = i / B;
        if(X[i] == 0) {
            zeroCnts[b]++;  // 해당 구간 0 개수 누적
        } else if(X[i] < 0) {
            negCnts[b]++;  // 해당 구간 음수 개수 누적
        }
    }
}

값을 변경하는 쿼리는 단순합니다. 원본 배열값과 0 개수/음수 개수 배열을 적절히 변경해주면 됩니다.

void Change(const int B, int i, ll V) {
    int val = Comp(V);
    if(X[i] == val) {  // 같으면 변경하지 않습니다
        return;
    }
    
    // 기존 정보 날리기
    int b = i / B;
    if(X[i] == 0) {
        zeroCnts[b]--;
    } else if(X[i] < 0) {
        negCnts[b]--;
    }
    
    // 새로운 정보 기록
    X[i] = val;
    if(X[i] == 0) {
        zeroCnts[b]++;
    } else if(X[i] < 0) {
        negCnts[b]++;
    }
}

곱 연산은 구간에 따라 적절히 처리하면 되는데요, i ~ j 부분 구간이 주어지면 [실제 배열로 처리할 왼쪽 자투리][ 블록 단위로 처리할 가운데 ][실제 배열로 처리할 오른쪽 자투리] 3 구간으로 나눠서 적절히 처리하면 됩니다. 만약 i, j가 같은 블록에 속한다면 그것에 대한 예외처리만 해주면 되죠.

void Product(const int B, const int i, const int j, string& out) {
    bool zero = false; int neg = 0;
    int bi = i / B, bj = j / B;
    
    if(bi == bj) {
        for(int idx = i; idx <= j; ++idx) {
            if(X[idx] == 0) {  // 0이면 결과가 0이니 즉시 break
                zero = true;
                break;
            }
            
            if(X[idx] < 0) {  // 음수 개수 카운팅
                neg++;
            }
        }
        
        if(zero) {
            out.push_back('0');
        } else {  // 음수 개수가 홀수면 -, 짝수라면 +
            out.push_back((neg & 1) ? '-' : '+');
        }
        
        return;
    }
    
    // 왼쪽 자투리 영역
    for(int idx = i; idx < (bi + 1) * B; ++idx) {
        if(X[idx] == 0) {
            zero = true;
            break;
        }
        
        if(X[idx] < 0) {
            neg++;
        }
    }
    
    // 가운데 블록 영역
    for(int b = bi + 1; b < bj && !zero; ++b) {
        if(zeroCnts[b] > 0) {
            zero = true;
            break;
        }
        
        neg += negCnts[b];
    }
    
    // 오른쪽 자투리 영역
    for(int idx = bj * B; idx <= j && !zero; ++idx) {
        if(X[idx] == 0) {
            zero = true;
            break;
        }
        
        if(X[idx] < 0) {
            neg++;
        }
    }
    
    if(zero) {
        out.push_back('0');
    } else {
        out.push_back((neg & 1) ? '-' : '+');
    }
    
    return;
}

전체 코드

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

inline int Comp(ll x) {
    if(x > 0) {
        return 1;
    } else if(x < 0) {
        return -1;
    } else {
        return 0;
    }
}

int N, K;
vector<int> X;
vector<int> zeroCnts;
vector<int> negCnts;
        
void Init(int& B, int& NB) {
    X.resize(N);
    
    B = max(1, (int)sqrt(N));
    NB = (N + B - 1) / B;
    
    zeroCnts.assign(NB, 0);
    negCnts.assign(NB, 0);
    
    for(int i = 0; i < N; ++i) {
        ll x; cin >> x;
        X[i] = Comp(x);
        
        int b = i / B;
        if(X[i] == 0) {
            zeroCnts[b]++;
        } else if(X[i] < 0) {
            negCnts[b]++;
        }
    }
}

void Change(const int B, int i, ll V) {
    int val = Comp(V);
    if(X[i] == val) {
        return;
    }
    
    int b = i / B;
    if(X[i] == 0) {
        zeroCnts[b]--;
    } else if(X[i] < 0) {
        negCnts[b]--;
    }
    
    X[i] = val;
    if(X[i] == 0) {
        zeroCnts[b]++;
    } else if(X[i] < 0) {
        negCnts[b]++;
    }
}

void Product(const int B, const int i, const int j, string& out) {
    bool zero = false; int neg = 0;
    int bi = i / B, bj = j / B;
    
    if(bi == bj) {
        for(int idx = i; idx <= j; ++idx) {
            if(X[idx] == 0) {
                zero = true;
                break;
            }
            
            if(X[idx] < 0) {
                neg++;
            }
        }
        
        if(zero) {
            out.push_back('0');
        } else {
            out.push_back((neg & 1) ? '-' : '+');
        }
        
        return;
    }
    
    for(int idx = i; idx < (bi + 1) * B; ++idx) {
        if(X[idx] == 0) {
            zero = true;
            break;
        }
        
        if(X[idx] < 0) {
            neg++;
        }
    }
    
    for(int b = bi + 1; b < bj && !zero; ++b) {
        if(zeroCnts[b] > 0) {
            zero = true;
            break;
        }
        
        neg += negCnts[b];
    }

    for(int idx = bj * B; idx <= j && !zero; ++idx) {
        if(X[idx] == 0) {
            zero = true;
            break;
        }
        
        if(X[idx] < 0) {
            neg++;
        }
    }

    if(zero) {
        out.push_back('0');
    } else {
        out.push_back((neg & 1) ? '-' : '+');
    }
    
    return;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    while((cin >> N >> K)) {
        int B, NB;
        Init(B, NB);
        
        string out; out.reserve(K);
        while(K--) {
            char cmd; cin >> cmd;
            if(cmd == 'C') {
                int i; ll V; cin >> i >> V;
                Change(B, i - 1, V);
            } else {
                int i, j; cin >> i >> j;
                Product(B, i - 1, j - 1, out);
            }
        }
        
        cout << out << "\n";
    }
    
    return 0;
}

[wnsmir]

i에서 j까지의 곱을 구하라는것을 보고
구간을 여러번 계산해야하는 점에서 그리고 변경이 자주 일어난다는 점에서

지난주 풀었던 세그먼트트리가 떠오르며 복습겸 이문제를 골랐구나 라는 생각이 스쳐지나갔습니다.

다시 트리 구현하려니까 .. 상당히 어렵네요

트리를 이용하는점 이외에는 간단했습니다.
다만 이전에는 리프노드들이 포함된 리스트를 부모노드로 간주했다면 이 문제에서는 노드들을 +1, -1, 0 이렇게만 저장해두었습니다.

노드의 부호가 중요하지 안의 숫자는 중요하지 않기 때문입니다.

즉 P 1 4 명령은 tree[1] 값만 읽으면 바로 그 구간의 곱을 알 수 있게 됩니다.

• 시간복잡도 == O(log N)

def sign(x):
    if x > 0: return 1
    elif x < 0: return -1
    else: return 0

# 세그먼트 트리 구축
def build(arr, tree, node, start, end):
    if start == end:
        tree[node] = sign(arr[start])
    else:
        mid = (start + end) // 2
        build(arr, tree, node*2, start, mid)
        build(arr, tree, node*2+1, mid+1, end)
        tree[node] = tree[node*2] * tree[node*2+1]

# 단일 값 갱신
def update(tree, node, start, end, idx, val):
    if start == end:
        tree[node] = sign(val)
    else:
        mid = (start + end) // 2
        if idx <= mid:
            update(tree, node*2, start, mid, idx, val)
        else:
            update(tree, node*2+1, mid+1, end, idx, val)
        tree[node] = tree[node*2] * tree[node*2+1]

# 구간 곱 쿼리
def query(tree, node, start, end, l, r):
    if r < start or end < l:   # 구간 벗어남
        return 1
    if l <= start and end <= r:  # 완전히 포함
        return tree[node]
    mid = (start + end) // 2
    left = query(tree, node*2, start, mid, l, r)
    right = query(tree, node*2+1, mid+1, end, l, r)
    return left * right

# 메인
N, K = map(int, input().split())
number = list(map(int, input().split()))

tree = [1] * (4*N)
build(number, tree, 1, 0, N-1)

result = []
for _ in range(K):
    order, I, V = input().split()
    I, V = int(I), int(V)

    if order == "C":
        update(tree, 1, 0, N-1, I-1, V)

    else:
        res = query(tree, 1, 0, N-1, I-1, V-1)
        if res > 0: result.append("+")
        elif res < 0: result.append("-")
        else: result.append("0")

print("".join(result))