https://www.acmicpc.net/problem/1725
๐ ์๋ฐ(Java)๋ก ํธ๋ ํ์คํ ๊ทธ๋จ์์ ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ ๋ฌธ์ ํ์ด
๐ ๋ฌธ์ ๊ฐ์
์ด ๋ฌธ์ ๋ ๋ฐฑ์ค "ํ์คํ ๊ทธ๋จ์์ ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ (1725๋ฒ)" ๋ฌธ์ ์
๋๋ค.
์ฃผ์ด์ง ํ์คํ ๊ทธ๋จ์์ ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ์ ๋์ด๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์
๋๋ค.
๐ก ์์ ์ ๋ ฅ
7
2
1
4
5
1
3
3
๐ก ์์ ์ถ๋ ฅ
8
์ ์
๋ ฅ์ ๋ํ ํ์คํ ๊ทธ๋จ์ ๊ทธ๋ ค๋ณด๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
์ด๋, ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ์ ๋์ด๋ 8์
๋๋ค.
๐ ์๊ณ ๋ฆฌ์ฆ ์ ๊ทผ ๋ฐฉ์
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์คํ(Stack) ์ ํ์ฉํ O(N) ์ต์ ํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํฉ๋๋ค.
โ๏ธ ์ฃผ์ ๊ณ ๋ ค ์ฌํญ
- ๊ฐ ํ์คํ ๊ทธ๋จ ๋ง๋์ ๋์ด(h)๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ง๋ค ์ ์๋ ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ์ ๋์ด๋ฅผ ๊ณ์ฐํด์ผ ํฉ๋๋ค.
- ์คํ์ ํ์ฉํ์ฌ ํจ์จ์ ์ผ๋ก ๋์ด๋ฅผ ๊ณ์ฐํ ์ ์์ต๋๋ค.
- ์คํ์๋ ํญ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์ฅํ์ฌ, ํ์ฌ ๋์ด๋ณด๋ค ๋ฎ์์ง๋ ๊ฒฝ์ฐ ๋์ด๋ฅผ ๊ณ์ฐํฉ๋๋ค.
- ์คํ์ด ๋น ๋๊น์ง ๋จ์ ๋์ด๋ค์ ๋ํ ๋์ด๋ ์ต์ข ์ ์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
๐น Java ์ฝ๋ ํด์ค
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class b1725 {
static int N; // ํ์คํ ๊ทธ๋จ์ ๋ง๋ ๊ฐ์
static long answer; // ๊ฐ์ฅ ํฐ ์ง์ฌ๊ฐํ์ ๋์ด
static Stack<int[]> stack; // ๋์ด์ ์์ ์์น๋ฅผ ์ ์ฅํ๋ ์คํ
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine()); // ๋ง๋ ๊ฐ์ ์
๋ ฅ
stack = new Stack<>();
answer = 0;
for (int i = 0; i < N; i++) {
int num = Integer.parseInt(br.readLine()); // ํ์ฌ ๋ง๋ ๋์ด ์
๋ ฅ
int start = i; // ๋ง๋๊ฐ ์์๋ ์์น
// ์คํ์ ์ต์๋จ ๊ฐ๋ณด๋ค ์์ ๋์ด๊ฐ ๋์ค๋ฉด ๋์ด ๊ณ์ฐ
while (!stack.isEmpty() && stack.peek()[0] > num) {
int[] top = stack.pop();
answer = Math.max(answer, (long) top[0] * (i - top[1]));
start = top[1]; // ์์ ์์น ์
๋ฐ์ดํธ
}
stack.push(new int[]{num, start}); // ํ์ฌ ๋ง๋ ์ ์ฅ
}
// ์คํ์ ๋จ์ ์๋ ๋์ด๋ค์ ๋ํ ๋์ด ๊ณ์ฐ
while (!stack.isEmpty()) {
int[] top = stack.pop();
answer = Math.max(answer, (long) top[0] * (N - top[1]));
}
System.out.println(answer); // ๊ฒฐ๊ณผ ์ถ๋ ฅ
}
}
๐ ์ฝ๋ ์ค๋ช
๐ 1. ์คํ ํ์ฉํ ๋์ด ๊ณ์ฐ
static Stack<int[]> stack;
- ์คํ์๋ {๋์ด, ์์ ์์น} ์์ ์ ์ฅํฉ๋๋ค.
- ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์ง๋๋ฉฐ, ๋ฎ์์ง๋ ๊ฒฝ์ฐ ์คํ์ ๋น์ฐ๋ฉด์ ๋์ด๋ฅผ ๊ณ์ฐํฉ๋๋ค.
๐ 2. ํ์ฌ ๋์ด๊ฐ ๊ธฐ์กด ์คํ๋ณด๋ค ๋ฎ์ผ๋ฉด ๋์ด ๊ณ์ฐ
while (!stack.isEmpty() && stack.peek()[0] > num) {
int[] top = stack.pop();
answer = Math.max(answer, (long) top[0] * (i - top[1]));
start = top[1]; // ์์ ์์น ์
๋ฐ์ดํธ
}
- ํ์ฌ ๋์ด๊ฐ ์คํ์ ์ต์๋จ๋ณด๋ค ๋ฎ๋ค๋ฉด, ๋์ด๋ฅผ ๊ณ์ฐํด์ผ ํจ
- ๋์ด ๊ณ์ฐ ๊ณต์:
ํ์ฌ ๋ง๋ ๋์ด * (ํ์ฌ ์ธ๋ฑ์ค - ์ ์ฅ๋ ์์ ์ธ๋ฑ์ค)
- ์คํ์ ๋์ด๊ฐ ๋ฎ์์ง ๋๊น์ง pop()ํ๋ฉด์ ๋์ด๋ฅผ ๊ฐฑ์
๐ 3. ์คํ์ ๋จ์ ์๋ ๊ฐ ์ฒ๋ฆฌ
while (!stack.isEmpty()) {
int[] top = stack.pop();
answer = Math.max(answer, (long) top[0] * (N - top[1]));
}
- ๋ฐฐ์ด์ ๋๊น์ง ๊ฐ์ ๋, ์คํ์ด ๋น์ด์์ง ์๋ค๋ฉด ์ต์ข ์ ์ผ๋ก ๋จ์ ๊ฐ๋ค์ ๊ณ์ฐํด์ผ ํฉ๋๋ค.
- ๋์ด ๊ณต์:
๋์ด * (์ ์ฒด ๊ธธ์ด - ์์ ์์น)
๐ฅ ์๊ฐ ๋ณต์ก๋ ๋ถ์
์ฐ์ฐ ์ต์ ์ ๊ฒฝ์ฐ ์ํ ํ์ ์๊ฐ ๋ณต์ก๋for ๋ฃจํ | N | O(N) |
while ๋ฃจํ (์คํ์์ pop) | N | O(N) |
while ๋ฃจํ (๋ง์ง๋ง ์ฒ๋ฆฌ) | N | O(N) |
์ดํฉ | O(N) |
๐ ๊ฒฐ๋ก
๐ ๋ชจ๋ ์ฐ์ฐ์ด O(N) ์ด๋ด๋ก ์ํ๋๋ฏ๋ก ํจ์จ์ ์
๋๋ค.
๐ ์ ๋ฆฌ
โ ํต์ฌ ํฌ์ธํธ
- ์คํ์ ํ์ฉํ์ฌ ํ์คํ ๊ทธ๋จ์ ๋์ด๋ฅผ ํจ์จ์ ์ผ๋ก ๊ณ์ฐํ๋ค.
- ๋์ด๊ฐ ๋ฎ์์ง๋ ์๊ฐ ์คํ์ ๋น์ฐ๋ฉด์ ์ง์ฌ๊ฐํ ๋์ด๋ฅผ ๊ณ์ฐํ๋ค.
- ๋ฐฐ์ด์ ๋๊น์ง ๊ฐ์ ๋, ๋จ์ ์คํ์ ํ ๋ฒ ๋ ์ฒดํฌํ๋ค.
- ์๊ฐ ๋ณต์ก๋๋ฅผ O(N)์ผ๋ก ์ต์ ํํ์ฌ ๋น ๋ฅด๊ฒ ํด๊ฒฐํ๋ค.
๐ฏ ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ฅ์
โ ์คํ์ ํ์ฉํ O(N) ํ์ด๋ก ํจ์จ์
โ ์ง์ฌ๊ฐํ ๋์ด๋ฅผ ๋น ๋ฅด๊ฒ ํ์ ๊ฐ๋ฅ
โ ๋ค๋ฅธ "Largest Rectangle" ๋ฌธ์ ์์๋ ํ์ฉ ๊ฐ๋ฅ
์ด ๊ธ์ด ๋์์ด ๋์๋ค๋ฉด, ์ข์์์ ๊ณต์ ๋ถํ๋๋ฆฝ๋๋ค! ๐
'Algorithm & Data Structures > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
b24480. ์๊ณ ๋ฆฌ์ฆ ์์ - ๊น์ด ์ฐ์ ํ์ 2 (0) | 2025.03.01 |
---|---|
b3015. ์ค์์์ค ์ฌ๊ฒฐํฉ (0) | 2025.02.25 |
b.17299 ์ค๋ฑํฐ์ (1) | 2025.02.04 |
b24497. ์๊ณ ๋ฆฌ์ฆ ์์ - ๊น์ด ์ฐ์ ํ์ 1 (0) | 2025.01.27 |
b.17298 ์คํฐ์ (1) | 2025.01.23 |