๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/133502
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก์ Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
ํ๋ฒ๊ฑฐ ๊ฐ๊ฒ์์ ์ผ์ ํ๋ ์์๋ ํ๋ฒ๊ฑฐ๋ฅผ ํฌ์ฅํ๋ ์ผ์ ํฉ๋๋ค. ํจ๊ป ์ผ์ ํ๋ ๋ค๋ฅธ ์ง์๋ค์ด ํ๋ฒ๊ฑฐ์ ๋ค์ด๊ฐ ์ฌ๋ฃ๋ฅผ ์กฐ๋ฆฌํด ์ฃผ๋ฉด ์กฐ๋ฆฌ๋ ์์๋๋ก ์์์ ์์ ์๋์๋ถํฐ ์๋ก ์์ด๊ฒ ๋๊ณ , ์์๋ ์์์ ๋ง๊ฒ ์์ฌ์ ์์ฑ๋ ํ๋ฒ๊ฑฐ๋ฅผ ๋ฐ๋ก ์ฎ๊ฒจ ํฌ์ฅ์ ํ๊ฒ ๋ฉ๋๋ค. ์์๊ฐ ์ผํ๋ ๊ฐ๊ฒ๋ ์ ํด์ง ์์(์๋์๋ถํฐ, ๋นต – ์ผ์ฑ – ๊ณ ๊ธฐ - ๋นต)๋ก ์์ธ ํ๋ฒ๊ฑฐ๋ง ํฌ์ฅ์ ํฉ๋๋ค. ์์๋ ์์ด ๊ต์ฅํ ๋น ๋ฅด๊ธฐ ๋๋ฌธ์ ์์๊ฐ ํฌ์ฅํ๋ ๋์ ์ ์ฌ๋ฃ๊ฐ ์ถ๊ฐ์ ์ผ๋ก ๋ค์ด์ค๋ ์ผ์ ์์ผ๋ฉฐ, ์ฌ๋ฃ์ ๋์ด๋ ๋ฌด์ํ์ฌ ์ฌ๋ฃ๊ฐ ๋์ด ์์ฌ์ ์ผ์ด ํ๋ค์ด์ง๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ์์์ ์์ ์์ด๋ ์ฌ๋ฃ์ ์์๊ฐ [์ผ์ฑ, ๋นต, ๋นต, ์ผ์ฑ, ๊ณ ๊ธฐ, ๋นต, ์ผ์ฑ, ๊ณ ๊ธฐ, ๋นต] ์ผ ๋, ์์๋ ์ฌ์ฏ ๋ฒ์งธ ์ฌ๋ฃ๊ฐ ์์์ ๋, ์ธ ๋ฒ์งธ ์ฌ๋ฃ๋ถํฐ ์ฌ์ฏ ๋ฒ์งธ ์ฌ๋ฃ๋ฅผ ์ด์ฉํ์ฌ ํ๋ฒ๊ฑฐ๋ฅผ ํฌ์ฅํ๊ณ , ์ํ ๋ฒ์งธ ์ฌ๋ฃ๊ฐ ์์์ ๋, ๋ ๋ฒ์งธ ์ฌ๋ฃ์ ์ผ๊ณฑ ๋ฒ์งธ ์ฌ๋ฃ๋ถํฐ ์ํ ๋ฒ์งธ ์ฌ๋ฃ๋ฅผ ์ด์ฉํ์ฌ ํ๋ฒ๊ฑฐ๋ฅผ ํฌ์ฅํฉ๋๋ค. ์ฆ, 2๊ฐ์ ํ๋ฒ๊ฑฐ๋ฅผ ํฌ์ฅํ๊ฒ ๋ฉ๋๋ค.
์์์๊ฒ ์ ํด์ง๋ ์ฌ๋ฃ์ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด ingredient๊ฐ ์ฃผ์ด์ก์ ๋, ์์๊ฐ ํฌ์ฅํ๋ ํ๋ฒ๊ฑฐ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์์ค.
์ ํ ์ฌํญ
- 1 ≤ ingredient์ ๊ธธ์ด ≤ 1,000,000
- ingredient์ ์์๋ 1, 2, 3 ์ค ํ๋์ ๊ฐ์ด๋ฉฐ, ์์๋๋ก ๋นต, ์ผ์ฑ, ๊ณ ๊ธฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ ์ถ๋ ฅ ์
| ingredient | result |
| [2, 1, 1, 2, 3, 1, 2, 3, 1] | 2 |
| [1, 3, 2, 1, 2, 1, 3, 1, 2] | 0 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ฌธ์ ์์์ ๊ฐ์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ์์๊ฐ ํฌ์ฅํ ์ ์๋ ํ๋ฒ๊ฑฐ๊ฐ ์์ต๋๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
import java.util.*;
class Solution {
public int solution(int[] ingredient) {
// ๋ง๋ค ์ ์๋ ํ๋ฒ๊ฑฐ์ ๊ฐ์
int answer = 0;
// ํ๋ฒ๊ฑฐ ์ฌ๋ฃ ์ ์ฅํ ์คํ ์์ฑ
Deque<Integer> stack = new ArrayDeque<>();
// ํ๋ฒ๊ฑฐ ์ฌ๋ฃ ์ํํ๋ฉด์ ํ๋ฒ๊ฑฐ ๋ง๋ค๊ธฐ
for (int ing : ingredient) {
// ์คํ์ ํ๋ฒ๊ฑฐ ์ฌ๋ฃ ์ ์ฅ
stack.push(ing);
// ์คํ์ ํฌ๊ธฐ๊ฐ 4 ์ด์์ผ ๊ฒฝ์ฐ ์ฌ๋ฃ ํ์ธ
if (stack.size() >= 4) {
// ์์๋๋ก ์ฌ๋ฃ ์ ์ฅ
int a = stack.pop();
int b = stack.pop();
int c = stack.pop();
int d = stack.pop();
// ํ๋ฒ๊ฑฐ ํจํด๊ณผ ๋น๊ตํ์ฌ ๋ง์ ๊ฒฝ์ฐ ํ๋ฒ๊ฑฐ ๊ฐ์ +1
if (d == 1 && c == 2 && b == 3 && a == 1) {
answer++;
// ์๋ ๊ฒฝ์ฐ ์ฌ๋ฃ ๋๋๋ฆฌ๊ธฐ
} else {
stack.push(d);
stack.push(c);
stack.push(b);
stack.push(a);
}
}
}
// ๋ง๋ ํ๋ฒ๊ฑฐ ๊ฐ์ ๋ฐํ
return answer;
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
์ฒ์ ๋ฌธ์ ๋ฅผ ๋ดค์ ๋, ํต์ฌ์ ์ฌ๋ฃ ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋๊น์ง ํ์ผ๋ฉด์ ์ต๊ทผ์ ์์ธ ๋ค ๊ฐ๊ฐ 1-2-3-1์ธ์ง๋ง ์ง์์ ์ผ๋ก ํ์ธํ๋ฉด ๋๋ค๊ณ ๋ณด์ ๋ค. ์ค๊ฐ ์ด๋๊ฐ์์ ํจํด์ด ์์ฑ๋๋ฉด ๊ทธ 4๊ฐ๋ฅผ ์ ๊ฑฐํ๊ณ ์นด์ดํธ๋ฅผ ์ฌ๋ฆฌ๋ฉด ๋๊ณ , ์ดํ ๊ฒ์ฌ๋ “์ด์ ์ํ์์ ์ด์ด์” ํ๋ฉด ๊ฒน์น๋ ํจํด๊น์ง ์์ฐ์ค๋ฝ๊ฒ ์กํ๋ค๊ณ ํ๋จํ๋ค.
์กฐ๊ฑด์ ๋ถ์ํด ๋ณด๋, ๋งค๋ฒ ๋ฆฌ์คํธ ์์ชฝ๋ถํฐ ๋ค์ ํ์ธํ๊ฑฐ๋ ์ค๊ฐ ์์๋ฅผ ์ญ์ ํ๋ฉด ๋น์ฉ์ด ์ปค์ง๋ค. ํนํ ArrayList๋ก ์ค๊ฐ ์ ๊ฑฐ๋ฅผ ๋ฐ๋ณตํ๋ฉด ์ฐ์์ ์ธ ์ด๋ ๋น์ฉ ๋๋ฌธ์ ์ต์ ์ ๊ฒฝ์ฐ O(n²)๊น์ง ๊ฐ ์ ์๋ค๊ณ ๋ณด์ ๋ค. ๋ ํ์ฒ๋ผ ์์์ ๋นผ๊ณ ๋ค์์ ๋ฃ๋ ๊ตฌ์กฐ๋ “์ต๊ทผ 4๊ฐ”๋ฅผ ์ง๊ด์ ์ผ๋ก ๋ค๋ฃจ๊ธฐ ์ด๋ ต๋ค.
๊ทธ๋์ ์๋ฃ๊ตฌ์กฐ๋ Deque๋ฅผ ์คํ์ฒ๋ผ ์ฐ๋ ๊ฒ ์ต์ ์ด๋ผ๊ณ ๊ฒฐ์ ํ๋ค. ์คํ์ ํญ์ ๋งจ ์(๊ฐ์ฅ ์ต์ )๋ง ๋ณด๋ฉด ๋๊ธฐ ๋๋ฌธ์ “์ต๊ทผ 4๊ฐ” ๊ฒ์ฌ์ ๋ฑ ๋ง๊ณ , push/pop์ด O(1)๋ก ๊ฐ๋ณ๋ค. ๋ํ Deque๋ ์ธ๋ฑ์ค ์ ๊ทผ(get)์ด ์์ด ์ค์ ๊ฐ๋ฅ์ฑ์ด ์ ๊ณ , peek๋ง์ผ๋ก๋ 4๊ฐ ๋์ ํ์ธ์ด ์ด๋ ค์ฐ๋ ํ์์ 4๊ฐ๋ฅผ ๊บผ๋ด์ ํ์ธํ ๋ค ๋ง์ผ๋ฉด ๋ฒ๋ฆฌ๊ณ , ์๋๋ฉด ๋ณต์ํ๋ ๋ฐฉ์์ด ์์ฐ์ค๋ฝ๋ค.
๋ก์ง ํ๋ฆ์ ์ด๋ ๋ค. ์ฌ๋ฃ๋ฅผ ํ๋์ฉ push ํ์ฌ ์๋๋ค. ์คํ ํฌ๊ธฐ๊ฐ 4 ์ด์์ด ๋๋ ์๊ฐ๋ง๋ค ๋งจ ์์์ 4๊ฐ๋ฅผ pop ํด ์์ ๋ฒํผ(๊ธธ์ด 4์ง๋ฆฌ ๊ณ ์ ๋ฐฐ์ด ๋ฑ)์ ๋ด๋๋ค. pop์ ํน์ฑ์ ๊บผ๋ธ ์์๋ ์→์๋์ด๋ฏ๋ก, ๋น๊ต ์ ์ญ์ ์ ํฉ์ฑ์ ์ ์ํด 1-2-3-1 ํจํด๊ณผ ์ผ์นํ๋์ง ํ์ธํ๋ค. ์ผ์นํ๋ฉด ์ด๋ฏธ 4๊ฐ๊ฐ ์ ๊ฑฐ๋ ์ํ์ด๋ฏ๋ก ๋ณต์ ์์ด ์นด์ดํธ๋ง ์ฆ๊ฐํ๋ค. ๋ถ์ผ์นํ๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ 4๊ฐ๋ฅผ ์๋ ์์๋ก ๋ณต์ํ๊ธฐ ์ํด ๊บผ๋ธ ์ญ์์ผ๋ก ๋ค์ push ํ๋ค. ์ด ๊ณผ์ ์ ๋๊น์ง ๋ฐ๋ณตํ๋ฉด, ์๋ก ๊ฒน์น๋ ํจํด๋ ์๋์ผ๋ก ์ฒ๋ฆฌ๋๋ค.
์ฃผ์ํ ์ ์ ์ธ ๊ฐ์ง๋ค. ์ฒซ์งธ, Deque์๋ ์ธ๋ฑ์ค ๊ธฐ๋ฐ get์ด ์์ผ๋ ์ธ๋ฑ์ค๋ก ๋น๊ตํ๋ ค ๋ค์ง ์๋๋ค. ๋์งธ, peek๋ง์ผ๋ก๋ 4๊ฐ๋ฅผ ๋์์ ์์ ํ๊ฒ ํ์ธํ๊ธฐ ์ด๋ ต๋ค. ์ ์งธ, ์์ ๋ฒํผ๋ ๊ณ ์ ํฌ๊ธฐ ๋ฐฐ์ด์ ์ฌ์ฌ์ฉํ๋ฉด ๋งค ๋ฐ๋ณต๋ง๋ค ๋ฆฌ์คํธ/๋ฐฐ์ด์ ์๋ก ๋ง๋ค์ง ์์ ํจ์จ์ฑ ํ ์คํธ์ ์ ๋ฆฌํ๋ค. ๋ฐฐ์ด ๋น๊ต๋ ์ฐธ์กฐ ๋๋ฑ์ฑ(==)์ด ์๋๋ผ ๋ด์ฉ ๋น๊ต๋ฅผ ํด์ผ ํ๋ค๋ ์ ๋ ์์ง ์๋๋ค.
์๊ฐ๋ณต์ก๋๋ ์ ๋ ฅ ๊ธธ์ด๋ฅผ n์ด๋ผ ํ ๋, ๊ฐ ์์๋ฅผ ํ ๋ฒ์ฉ push ํ๊ณ , ๊ฒ์ฌ ์ ์ต๋ 4๋ฒ์ pop/push๋ง ์ํํ๋ฏ๋ก ์ ์ฒด๊ฐ O(n)์ด๋ค. ์ถ๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ ์คํ๊ณผ ๊ธธ์ด 4์ ์์ ๋ฒํผ ์ ๋๋ก O(n)/O(1) ์์ค์ด๋ฉฐ, ArrayList ๊ธฐ๋ฐ์ ๋ฐ๋ณต ์ญ์ ·์ฌ๊ฒ์ฌ๋ณด๋ค ํจ์ฌ ์์ ์ ์ผ๋ก ํจ์จ์ฑ ์กฐ๊ฑด์ ํต๊ณผํ ์ ์๋ค๊ณ ํ๋จํ๋ค.
'๐ฆ ํ๋ก๊ทธ๋๋จธ์ค > ๐๏ธ ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ ๋ฐ๋จน๊ธฐ (0) | 2025.10.13 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋คํธ ๊ฒ์ (0) | 2025.10.02 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ฌธ์์ด ๋๋๊ธฐ (0) | 2025.09.26 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋๋ง์ ์ํธ (0) | 2025.09.25 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ ๋งต๊ฒ (0) | 2025.09.23 |