[ํ ์ฝํ ์ฝ1.5 2-05] ๋ง๋๊ธฐ
๐กํ ์ฝํ ์ฝ ์์ฆ 1.5 2ํ ๋ชจ์ off-site ๋ฌธ์ ํ์ด์ ๋๋ค. (2025.01.19)
๋ฌธ์
์ถ์ฒ: ๋ฐฑ์ค - ๋ง๋๊ธฐ
๋ด์ฉ
์๋ ๊ทธ๋ฆผ์ฒ๋ผ ๋์ด๋ง ๋ค๋ฅด๊ณ (๊ฐ์ ๋์ด์ ๋ง๋๊ธฐ๊ฐ ์์ ์ ์์) ๋ชจ์์ด ๊ฐ์ ๋ง๋๊ธฐ๋ฅผ ์ผ๋ ฌ๋ก ์ธ์ด ํ, ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋ก ๋ฒํธ๋ฅผ ๋ถ์ธ๋ค. ๊ฐ ๋ง๋๊ธฐ์ ๋์ด๋ ๊ทธ๋ฆผ์์ ๋ณด์ธ ๊ฒ์ฒ๋ผ ์์๋๋ก 6, 9, 7, 6, 4, 6 ์ด๋ค. ์ผ๋ ฌ๋ก ์ธ์์ง ๋ง๋๊ธฐ๋ฅผ ์ค๋ฅธ์ชฝ์์ ๋ณด๋ฉด ๋ณด์ด๋ ๋ง๋๊ธฐ๊ฐ ์๊ณ ๋ณด์ด์ง ์๋ ๋ง๋๊ธฐ๊ฐ ์๋ค. ์ฆ, ์ง๊ธ ๋ณด์ด๋ ๋ง๋๊ธฐ๋ณด๋ค ๋ค์ ์๊ณ ๋์ด๊ฐ ๋์ ๊ฒ์ด ๋ณด์ด๊ฒ ๋๋ค. ์๋ฅผ ๋ค์ด, ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์ 3๊ฐ(6๋ฒ, 3๋ฒ, 2๋ฒ)์ ๋ง๋๊ธฐ๊ฐ ๋ณด์ธ๋ค.
N๊ฐ์ ๋ง๋๊ธฐ์ ๋ํ ๋์ด ์ ๋ณด๊ฐ ์ฃผ์ด์ง ๋, ์ค๋ฅธ์ชฝ์์ ๋ณด์์ ๋ช ๊ฐ๊ฐ ๋ณด์ด๋์ง๋ฅผ ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ ค๊ณ ํ๋ค.
๊ธฐ๋กํ๊ธฐ
๐ก ์ด๋๊น์ง ์๊ฐํด๋ดค๋์ง ๋จ๊ณ์ ์ผ๋ก ๊ธฐ๋กํด๋ด ๋๋ค.
์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ ค ํ๋์?
์คํ์ ์ฌ์ฉํ๋ค.
์ ์ฉ ๊ทผ๊ฑฐ๋ ๋ฌด์์ธ๊ฐ์?
๊ฐ์ฅ ๊ฐ๊น์ด, ํน์ ๊ฐ์ฅ ์ต๊ทผ์ ๊ฐ์ ๋น๊ตํ ๋ ์คํ์ด ์ฉ์ดํ๋ค.
ํ์ด
ํ์ด ์๊ฐ
์์ ์๊ฐ | ์ข ๋ฃ ์๊ฐ | ์ด ์์ ์๊ฐ |
---|---|---|
17:45 | 17:56 | 11๋ถ |
๋ฌธ์ ๋ถ์
์ ์ฝ ์ฌํญ ํ์ & ์ ๋ ฅ๊ฐ ๋ถ์
๐ก ์ ๋ ฅ๊ฐ์ ๋ถ์ํ๋ฉด ๋ฌธ์ ์์ ์๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ ์ ์ผ๋ก ํ์ ํ ์ ์์ต๋๋ค.
์ฒซ ๋ฒ์งธ ์ค์๋ ๋ง๋๊ธฐ์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ N (2 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๊ณ ์ด์ด์ง๋ N์ค ๊ฐ๊ฐ์๋ ๋ง๋๊ธฐ์ ๋์ด๋ฅผ ๋ํ๋ด๋ ์ ์ h(1 ≤ h ≤ 100,000)๊ฐ ์ฃผ์ด์ง๋ค.
6
6
9
7
6
4
6
์ค๋ฅธ์ชฝ์์ N๊ฐ์ ๋ง๋๊ธฐ๋ฅผ ๋ณด์์ ๋, ๋ณด์ด๋ ๋ง๋๊ธฐ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
3
์์ฌ ์ฝ๋ ์์ฑ
๐ก ์์ฌ ์ฝ๋๋ ๋์ ์ค์ฌ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ ๋ฌธ์ ํด๊ฒฐ ์์๋ก ์์ฑํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ฅผ ์ถฉ๋ถํ ํ ์คํธํด๋ด ๋๋ค.
soltion() {
// 1. ๋ง๋๊ธฐ ๊ฐ์ int N ๋ฐ๊ธฐ
// 2. ์คํ ์์ฑ
for (int i = 0; i < N; i++) {
// 3. ๋ง๋๊ธฐ ๋์ด int h ๋ฐ๊ธฐ
while (์คํ์ ๊ฐ ์๊ณ h > top ์ผ๋) {
stack.pop();
}
if (์คํ์ด ๋น์ด์๊ฑฐ๋ h < top ์ด๋ฉด) {
stack.push(h);
}
}
System.out.println(stack.size());
}
๊ตฌํ
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.parseInt(bufferedReader.readLine());
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < N; i++) {
int h = Integer.parseInt(bufferedReader.readLine());
while (!stack.isEmpty() && h > stack.peek()) {
stack.pop();
}
if (stack.isEmpty() || h < stack.peek()) {
stack.push(h);
}
}
System.out.println(stack.size());
}
}
์์ฝํ๊ธฐ
- ์ด๊ฒ ๋ฐ๋ก ๋ชจ๋ ธํ ๋ ์คํ..!