์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ | ์ ๋ต ๋น์จ |
1 ์ด | 256 MB | 47.180% |
10868๋ฒ: ์ต์๊ฐ
N(1 ≤ N ≤ 100,000)๊ฐ์ ์ ์๋ค์ด ์์ ๋, a๋ฒ์งธ ์ ์๋ถํฐ b๋ฒ์งธ ์ ์๊น์ง ์ค์์ ์ ์ผ ์์ ์ ์๋ฅผ ์ฐพ๋ ๊ฒ์ ์ด๋ ค์ด ์ผ์ด ์๋๋ค. ํ์ง๋ง ์ด์ ๊ฐ์ a, b์ ์์ด M(1 ≤ M ≤ 100,000)๊ฐ ์ฃผ์ด์ก์ ๋๋
www.acmicpc.net
๋ฌธ์
N(1 ≤ N ≤ 100,000)๊ฐ์ ์ ์๋ค์ด ์์ ๋, a๋ฒ์งธ ์ ์๋ถํฐ b๋ฒ์งธ ์ ์๊น์ง ์ค์์ ์ ์ผ ์์ ์ ์๋ฅผ ์ฐพ๋ ๊ฒ์ ์ด๋ ค์ด ์ผ์ด ์๋๋ค. ํ์ง๋ง ์ด์ ๊ฐ์ a, b์ ์์ด M(1 ≤ M ≤ 100,000)๊ฐ ์ฃผ์ด์ก์ ๋๋ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ๋๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ณด์.
์ฌ๊ธฐ์ a๋ฒ์งธ๋ผ๋ ๊ฒ์ ์ ๋ ฅ๋๋ ์์๋ก a๋ฒ์งธ๋ผ๋ ์ด์ผ๊ธฐ์ด๋ค. ์๋ฅผ ๋ค์ด a=1, b=3์ด๋ผ๋ฉด ์ ๋ ฅ๋ ์์๋๋ก 1๋ฒ, 2๋ฒ, 3๋ฒ ์ ์ ์ค์์ ์ต์๊ฐ์ ์ฐพ์์ผ ํ๋ค. ๊ฐ๊ฐ์ ์ ์๋ค์ 1์ด์ 1,000,000,000์ดํ์ ๊ฐ์ ๊ฐ๋๋ค.
์ฒซ์งธ ์ค์ N, M์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ M๊ฐ์ ์ค์๋ a, b์ ์์ด ์ฃผ์ด์ง๋ค.
M๊ฐ์ ์ค์ ์
๋ ฅ๋ฐ์ ์์๋๋ก ๊ฐ a, b์ ๋ํ ๋ต์ ์ถ๋ ฅํ๋ค.
ํด๊ฒฐ
key point, ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ
- ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ ํธ๋ฆฌ์ ๋์ด๋ฅผ ๊ตฌํ๋ค. → h
- ๋ฆฌํ ๋ ธ๋์ ์ ๋ ฅ๋ฐ์ ์๋ฅผ ์ฐจ๋ก๋ก ๋์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋ฆฌํ๋ ธ๋์ ๊ฐ์๊ฐ n๋ณด๋ค ํฌ๊ฒ๋ while๋ฌธ์ ํ์ฉํ์ฌ ๋์ด๋ฅผ ๊ตฌํด์ค๋ค.
- ๋ฆฌํ ๋ ธ๋๋ฅผ ์ ์ธํ ๋ ธ๋๋ ๊ตฌ๊ฐ์ ์ต์๊ฐ์ ๊ฐ๊ณ ์๋๋ค.
- ํด๋น ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ์์๋ ๊ตฌ๊ฐ์ ์ต์๊ฐ์ ๊ตฌํด์ผ ํ๊ธฐ ๋๋ฌธ์ INF ๋ฌดํ๋ ๊ฐ์ผ๋ก ์ด๊ธฐํ ํ๋ค. → fill(seg.begin(), seg.end(), INF)
- udpate ํจ์๋ i ์์น์ num์ ์ ์ฅํ๋ ๊ฒ์ด๊ณ , ์ฒ์์ i + h๋ก ๋ฆฌํ๋ ธ๋์ ์ ์ฅ์ํจ ํ์ /= 2๋ฅผ ํ๋ฉฐ ์กฐ์ ๋ ธ๋๋ก ์ฌ๋ผ๊ฐ ๊ตฌ๊ฐ์ ์ต์๊ฐ์ ์ ์ฅํ๋ค.
- query ํจ์๋ ๊ตฌ๊ฐ์ ์ต์๊ฐ์ ๊ตฌํ๋ ํจ์๋ค.
- l, r์ ์ฐพ๊ณ ์ ํ๋ ๋ฒ์์ ์์๊ณผ ๋์ด๊ณ , num์ ํ์ฌ ๋ณด๊ณ ์๋ ๋ ธ๋ ๋ฒํธ, nl, nr์ ํ์ฌ ๋ณด๊ณ ์๋ ๋ฒ์์ ์์๊ณผ ๋์ด๋ค.
- ๊ตฌ๊ฐ์ ๋ฐ๋ผ์ ์ต์๊ฐ์ ๋ฐํํ๊ฑฐ๋, ๋ฌดํ๋๊ฐ์ ๋ฐํํ๊ฑฐ๋, ์ฌ๊ทํจ์๋ฅผ ํตํด ๋ต์ ๊ตฌํ๋ค.
์ฝ๋
๋ฉ๋ชจ๋ฆฌ | ์๊ฐ |
3280 KB | 112 ms |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long int ll;
#define INF 1e9
int n, m, h = 1;
vector<ll> seg;
void update(int i, int num) {
i += h;
seg[i] = num;
while (i > 1) {
i /= 2;
seg[i] = min(seg[i * 2], seg[i * 2 + 1]);
}
}
// l, r ์ฐพ๋ ๋ฒ์, num ํ์ฌ ๋
ธ๋ ๋ฒํธ, nl, nr ํ์ฌ ๋ฒ์
ll query(int l, int r, int num, int nl, int nr) {
if (l <= nl && nr <= r) return seg[num];
if (nl > r || nr < l) return INF;
int mid = (nl + nr) / 2;
return min(query(l, r, num * 2, nl, mid), query(l, r, num * 2 + 1, mid + 1, nr));
}
int main() {
scanf("%d%d", &n, &m);
while (h < n) h <<= 1;
seg.resize(h * 2);
fill(seg.begin(), seg.end(), INF);
for (int i = 0, a; i < n; i++) {
scanf("%d", &a);
update(i, a);
}
for (int i = 0, a, b; i < m; i++) {
scanf("%d%d", &a, &b);
printf("%lld\n", query(a, b, 1, 1, h));
}
return 0;
}
|
cs |
'๐ฅ PS(Problem Solving) ๐ฅ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] #2042 ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ (0) | 2021.02.15 |
---|---|
[BOJ] #11505 ๊ตฌ๊ฐ ๊ณฑ ๊ตฌํ๊ธฐ (0) | 2021.02.15 |
[BOJ] #1509 ํฐ๋ฆฐ๋๋กฌ ๋ถํ (0) | 2021.02.09 |
[BOJ] #10942 ํฐ๋ฆฐ๋๋กฌ? (0) | 2021.02.09 |
[BOJ] #2632 ํผ์ํ๋งค (0) | 2021.02.05 |
๋๊ธ