Algorithm
ํ๋ก๊ทธ๋๋จธ์ค: ๋กค์ผ์ดํฌ ์๋ฅด๊ธฐ(JAVA)
10Biliion
2025. 5. 29. 10:58
๋ฐ์ํ
๐งฉ ๋ฌธ์ ์ค๋ช
์ฒ ์๋ ๋์์๊ฒ ๋กค์ผ์ดํฌ์ ์ ๋ฐ์ ๊ณตํํ๊ฒ ๋๋ ์ฃผ๋ ค๊ณ ํฉ๋๋ค.
- ๋กค์ผ์ดํฌ์๋ ์ฌ๋ฌ ์ข ๋ฅ์ ํ ํ์ด ์์๋๋ก ๋์ฌ ์๊ณ ,
- ์ฒ ์๋ ํ ํ์ด ๋์ธ ์์๋๋ก ํ ์กฐ๊ฐ์ฉ ์ผ์ชฝ์ผ๋ก ์๋ฅผ ์ ์์ต๋๋ค.
- ์ด๋ ์์ ๊ณผ ๋์์ด ๊ฐ๊ฒ ๋๋ ํ ํ์ ์ข ๋ฅ ์๊ฐ ๊ฐ์์ง๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํด์ผ ํฉ๋๋ค.
โ์์
์
๋ ฅ: [1, 2, 1, 3, 1, 4, 1, 2]
์ถ๋ ฅ: 2
ํ์ด๋ฐฉ๋ฒ
- ์ ์ฒด ํ ํ ๊ฐ์๋ฅผ Map์ผ๋ก ์ธ์ด๋๋ค.
- ์ผ์ชฝ๋ถํฐ ํ ์นธ์ฉ ์๋ฅด๋ฉด์:
- ์ผ์ชฝ ํ ํ ์ข ๋ฅ๋ Set์ผ๋ก ๊ด๋ฆฌํ๊ณ ,
- ์ค๋ฅธ์ชฝ ํ ํ ์ข ๋ฅ๋ Map์์ ํ๋์ฉ ๊ฐ์์ํค๋ฉฐ ๊ด๋ฆฌํฉ๋๋ค.
- ์์ชฝ์ ํ ํ ์ข ๋ฅ ์(Set.size() vs Map.size())๊ฐ ๊ฐ์ผ๋ฉด answer ์ฆ๊ฐ
JAVA ์ฝ๋
import java.util.*;
class Solution {
public int solution(int[] topping) {
int answer = 0;
Map<Integer, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();
// 1. ์ ์ฒด ํ ํ์ ๊ฐ์๋ฅผ ์ผ๋ค
for (int i = 0; i < topping.length; i++) {
map.put(topping[i], map.getOrDefault(topping[i], 0) + 1);
}
// 2. ํ ์นธ์ฉ ์๋ฅด๋ฉด์ ๋น๊ต
for (int i = 0; i < topping.length; i++) {
int num = topping[i];
set.add(num); // ์ผ์ชฝ์ ์ถ๊ฐ
map.put(num, map.get(num) - 1); // ์ค๋ฅธ์ชฝ์์ ์ ๊ฑฐ
if (map.get(num) == 0) {
map.remove(num); // ์๊ฐ 0์ด ๋๋ฉด ์ ๊ฑฐ
}
// ์์ชฝ ํ ํ ์ข
๋ฅ ์๊ฐ ๊ฐ์ผ๋ฉด ์ ๋ต++
if (set.size() == map.size()) {
answer++;
}
}
return answer;
}
}
ํฌ์ธํธ
์ค๋ฅธ์ชฝ ํ ํ ์ข
๋ฅ ๊ฐ์ ๊ด๋ฆฌ -> Map
์ผ์ชฝ ํ ํ์ ์ข
๋ฅ ์ถ์ ->Set
๐ ์ด๋ฐ ๋ฌธ์ ์์๋ "์ข
๋ฅ ์" = Set/Map size ๋ฅผ ๋ ์ฌ๋ฆฌ๋ ์ต๊ด์ด ์ค์.
์๊ฐ๋ณต์ก๋
O(N)
์ ์ฒด ๋ฐฐ์ด์ ๋ ๋ฒ ์ํํ๋ฏ๋ก ์ ํ ์๊ฐ ๋ณต์ก๋๋ก ํจ์จ์
๋ฐ์ํ