
๋ฌธ์
์์ ์ด๋ ์ด๋ฆฐ ๋์์ ๋ฌ๋๊ธฐ ์ํด์ ์ฌํ์ ์ฌ์ฉํ๋ค. ์์ ์ด๋ ํ์์ ์ฌ๋ฌ ๊ฐ์ ์ฌํ์ ์ฌ์ ์ฌํ์์์ ๋ฃ์ด๋๊ณ , ๋์์ด ๋ง์ ์ ๋ค์ ๋๋ฉด ๊ทธ ์์์ ์ฌํ์ ๊บผ๋ด์ ์ฃผ๊ณค ํ๋ค.
๊ฐ๊ฐ์ ์ฌํ์ ๊ทธ ๋ง์ ์ข๊ณ ๋์จ์ด 1๋ถํฐ 1,000,000๊น์ง์ ์ ์๋ก ๊ตฌ๋ถ๋๋ค. 1์ด ๊ฐ์ฅ ๋ง์๋ ์ฌํ์ ์๋ฏธํ๋ฉฐ, 1,000,000์ ๊ฐ์ฅ ๋ง์๋ ์ฌํ์ ์๋ฏธํ๋ค. ์์ ์ด๋ ๋์์ด ๋ง์ ์ ๋ค์ ์ ๋์ ๋ฐ๋ผ์, ์ฌํ์์ ์์ ์๋ ์ฌํ๋ค ์ค ๋ช ๋ฒ์งธ๋ก ๋ง์๋ ์ฌํ์ ๊บผ๋ด์ฃผ๊ณค ํ๋ค. ์๋ฅผ ๋ค์ด ๋ง์ ๋งค์ฐ ์ ๋ค์์ ๋์๋ ์ฌํ์์์์ ๊ฐ์ฅ ๋ง์๋ ์ฌํ์ ๊บผ๋ด์ฃผ๊ณ , ๋ง์ ์กฐ๊ธ ์ ๋ค์์ ๋์๋ ์ฌํ์์์์ ์ฌ์ฏ ๋ฒ์งธ๋ก ๋ง์๋ ์ฌํ์ ๊บผ๋ด์ฃผ๋ ์์ด๋ค.
์์ ์ด๊ฐ ๋ณด๊ดํ๊ณ ์๋ ์ฌํ์ ๋งค์ฐ ๋ง๊ธฐ ๋๋ฌธ์ ๋งค๋ฒ ์ฌํ์์๋ฅผ ๋ค์ ธ์ ๊บผ๋ผ ์ฌํ์ ๊ณจ๋ผ๋ด๋ ์ผ์ ๋งค์ฐ ์ด๋ ต๋ค. ์์ ์ด๋ฅผ ๋์์ฃผ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์์ ์ด๊ฐ ์ฌํ์์์ ์์ ๋ ํ์ n(1 ≤ n ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ n๊ฐ์ ์ค์๋ ๋ ์ ์ A, B, ํน์ ์ธ ์ ์ A, B, C๊ฐ ์ฃผ์ด์ง๋ค. A๊ฐ 1์ธ ๊ฒฝ์ฐ๋ ์ฌํ์์์์ ์ฌํ์ ๊บผ๋ด๋ ๊ฒฝ์ฐ์ด๋ค. ์ด๋์๋ ํ ์ ์๋ง ์ฃผ์ด์ง๋ฉฐ, B๋ ๊บผ๋ผ ์ฌํ์ ์์๋ฅผ ์๋ฏธํ๋ค. ์ด ๊ฒฝ์ฐ ์ฌํ์์์์ ํ ๊ฐ์ ์ฌํ์ด ๊บผ๋ด์ง๊ฒ ๋๋ค. ๋, A๊ฐ 2์ธ ๊ฒฝ์ฐ๋ ์ฌํ์ ๋ฃ๋ ๊ฒฝ์ฐ์ด๋ค. ์ด๋์๋ ๋ ์ ์๊ฐ ์ฃผ์ด์ง๋๋ฐ, B๋ ๋ฃ์ ์ฌํ์ ๋ง์ ๋ํ๋ด๋ ์ ์์ด๊ณ C๋ ๊ทธ๋ฌํ ์ฌํ์ ๊ฐ์์ด๋ค. C๊ฐ ์์์ผ ๊ฒฝ์ฐ์๋ ์ฌํ์ ๋ฃ๋ ๊ฒฝ์ฐ์ด๊ณ , ์์์ผ ๊ฒฝ์ฐ์๋ ๋นผ๋ ๊ฒฝ์ฐ์ด๋ค. ๋งจ ์ฒ์์๋ ๋น ์ฌํ์์์์ ์์ํ๋ค๊ณ ๊ฐ์ ํ๋ฉฐ, ์ฌํ์ ์ด ๊ฐ์๋ 2,000,000,000์ ๋์ง ์๋๋ค. ๋ํ ์๋ ์ฌํ์ ๊บผ๋ด๋ ๊ฒฝ์ฐ์ ๊ฐ์ ์๋ชป๋ ์ ๋ ฅ์ ์ฃผ์ด์ง์ง ์๋๋ค.
์ถ๋ ฅ
A๊ฐ 1์ธ ๋ชจ๋ ์ ๋ ฅ์ ๋ํด์, ๊บผ๋ผ ์ฌํ์ ๋ง์ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ
6
2 1 2
2 3 3
1 2
1 2
2 1 -1
1 2
์์ ์ถ๋ ฅ
1
3
3
ํด๊ฒฐ ๋ฐฉ๋ฒ
Tree[ ] ์๋ (start ~ end) ๋ฒ์์ ์ํ๋ ๋ง์ ๊ฐ์ง ์ฌํ๋ค์ ์ดํฉ์ ๊ธฐ๋กํฉ๋๋ค.
[ update ]
์ฐจ์ด๊ฐ์ผ๋ก ์ ๋ฐ์ดํธ ํ๋ ๋ฐฉ์์ ๋๋ค.
[ query ]
mid = (start + end) / 2
mid ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ ์์์ด ๋ง์๋ ์ชฝ์ ๋ค๋ฃจ๊ณ ์์ต๋๋ค.
์ฐพ์ผ๋ ค๋ ์์์ ์(k) ๊ฐ tree[์ผ์ชฝ์์] ๋ณด๋ค ์๋ค๋ฉด ์ผ์ชฝ ์์์ ๋ฒ์ ๋ด์ ์ฐ๋ฆฌ๊ฐ ์ฐพ์ผ๋ ค๋ ์ธ๋ฑ์ค๊ฐ ์๋ ๊ฒ์ด๋ฏ๋ก
-> query(์ผ์ชฝ ์์ ๋ ธ๋, 0, mid, k)๋ฅผ ํธ์ถ
์ฐพ์ผ๋ ค๋ ์์๊ฐ tree[์ผ์ชฝ ์์] ๋ณด๋ค ํฌ๋ค๋ฉด ์ค๋ฅธ์ชฝ ์์์ด ๋ค๋ฃจ๋ ๋ฒ์ ์์ ์๋ค๋ ์๋ฏธ์ด๋ฏ๋ก
์ค๋ฅธ์ชฝ ์์์์ (k - tree[์ผ์ชฝ์์])๋ฒ์งธ ์์๋ฅผ ์ฐพ์์ผ ํฉ๋๋ค.
-> query (์ค๋ฅธ์ชฝ ์์ ๋ ธ๋, mid + 1, end, k)
์ฝ๋
import java.util.*;
import java.io.*;
public class Main {
public static class SegmentTree {
// ๋ง์ ๊ฐ๋ ๋ฒ์
long[] tree;
int n;
SegmentTree() {
n = 1_000_001;
tree = new long[4*n];
}
public void update(int b, long c) {
updateHelper(1, 0, n-1, b, c);
}
private void updateHelper(int node, int start, int end, int b, long c) {
if (b < start || b > end) return;
tree[node] += c;
if (start != end) {
int mid = (start + end) / 2;
updateHelper(node * 2, start, mid, b, c);
updateHelper(node * 2 + 1, mid + 1, end, b, c);
}
}
public int query(int b) {
return queryHelper(1, 0, n-1, b);
}
private int queryHelper(int node, int start, int end, long b) {
if (start == end) {
return start;
}
int mid = (start + end) / 2;
// ๋ง์ด ๋ ์ข์ ์ชฝ
long leftCount = tree[node * 2];
if ( b <= leftCount ) {
return queryHelper(node * 2, start, mid, b);
}
else {
return queryHelper(node * 2 + 1, mid + 1, end, b - leftCount);
}
}
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
SegmentTree segTree = new SegmentTree();
for (int i = 0; i < n; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
// ๊บผ๋ด๊ธฐ
if (a == 1) {
int b = Integer.parseInt(st.nextToken());
int idx = segTree.query(b);
sb.append(idx).append("\n");
segTree.update(idx, -1);
}
// ๋ฃ๊ธฐ
else if (a == 2) {
int b = Integer.parseInt(st.nextToken());
long c = Long.parseLong(st.nextToken());
segTree.update(b, c);
}
}
System.out.print(sb);
}
}

'๐์ฝ๋ฉํ ์คํธ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [๋ฐฑ์ค] 2268 - ์๋ค์ ํฉ 7 (Java) (0) | 2026.03.12 |
|---|---|
| [๋ฐฑ์ค] 12899 - ๋ฐ์ดํฐ ๊ตฌ์กฐ (Java) (0) | 2026.03.12 |
| [๋ฐฑ์ค] 16975 - ์์ด๊ณผ ์ฟผ๋ฆฌ 21 (Java) (0) | 2026.03.12 |
| [๋ฐฑ์ค] 10868 - ์ต์๊ฐ (Java) (1) | 2026.03.12 |
| [๋ฐฑ์ค] 10999 - ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ 2 (Java) (0) | 2026.03.11 |
์ฌ์ฐ๋น์ ๊ฐ๋ฐ ๋ธ๋ก๊ทธ
https://www.youtube.com/watch?v=SVGTzOL357Y&list=RDSVGTzOL357Y&start_radio=1