Notice
Recent Posts
Recent Comments
Link
| ์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
|---|---|---|---|---|---|---|
| 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 |
Tags
- JavaCodingTest
- ์๋ฐ
- ์ฝํ ์๋ฐ
- Android
- ๋ฐฑ์ค
- kotlin
- ์ฝ๋ฉํ ์คํธ ์๋ฐ
- pattern
- ๋ทฐ๋ฐ์ธ๋ฉ
- ํ๋ฉด ํฌ๊ธฐ ๊ตฌํ๊ธฐ
- baekjoon
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- CodingTest
- ์ค๋ธ์
- ์ฝ๋ฉํ ์คํธ
- Java
- ์ฝํ๋ฆฐ
- Coding-Test
- javaCoding
- ์ฐํ ํ๊ธ๋ฐ
- BottomNavigation
- programmers
- CodingTestJava
- ModelViewPresenter
- ์ฝ๋ฉํ ์คํธ JAVA
- ScreenSize
- viewpager2
- ์๋ฐ ์ฝ๋ฉํ ์คํธ
- ์๋๋ก์ด๋
- ์ฝํ
Archives
- Today
- Total
KDLiam
[Programmers : Java] ์ต๋น๊ฐ ๊ตฌํ๊ธฐ ๋ณธ๋ฌธ
๐ฏ Programmers 120812 — ์ต๋น๊ฐ ๊ตฌํ๊ธฐ
๐ ๋ฌธ์ ๋งํฌ: ํ๋ก๊ทธ๋๋จธ์ค 120812 - ์ต๋น๊ฐ ๊ตฌํ๊ธฐ
๐ ๋ฌธ์ ์์ฝ
์ ์ ๋ฐฐ์ด array๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ์ฅ ์์ฃผ ๋ฑ์ฅํ ์(์ต๋น๊ฐ)๋ฅผ ๋ฐํํ์์ค.
๋จ, ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด -1์ ๋ฐํํฉ๋๋ค.
๐ก 1๏ธโฃ ๋ฐฐ์ด ๊ธฐ๋ฐ ํ์ด
class Solution {
public int solution(int[] array) {
int[] numCnt = new int[1000]; // ๋น๋ ์นด์ดํ
์ฉ ๋ฐฐ์ด
int max = -1;
// 1๋จ๊ณ: ๊ฐ ์ซ์์ ๋น๋ ์ธ๊ธฐ + ์ต๋ ๋น๋ ์ฐพ๊ธฐ
for (int i = 0; i < array.length; i++) {
numCnt[array[i]]++;
if (numCnt[array[i]] > max) {
max = numCnt[array[i]];
}
}
// 2๋จ๊ณ: ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ธ์ง ํ์ธ
int cnt = 0;
int maxIndex = 0;
for (int i = 0; i < numCnt.length; i++) {
if (numCnt[i] == max) {
cnt++;
maxIndex = i;
}
if (cnt > 1) return -1; // ์ฌ๋ฌ ๊ฐ๋ฉด -1
}
return maxIndex;
}
}
โ ์ฅ์
- ๋น ๋ฅธ ์๋
- ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ก ์ง์ ์ ๊ทผํ๋ฏ๋ก ํด์ ์ฐ์ฐ์ด ํ์ ์์
- ์๊ฐ ๋ณต์ก๋: O(N + K)
(N: ๋ฐฐ์ด ํฌ๊ธฐ, K: numCnt ๋ฐฐ์ด ํฌ๊ธฐ = 1000์ผ๋ก ์์)
- ๋จ์ํ๊ณ ์ง๊ด์
- ๋ณ๋์ ์๋ฃ๊ตฌ์กฐ ์์ด ๊ธฐ๋ณธ for๋ฌธ์ผ๋ก๋ง ๊ตฌํ ๊ฐ๋ฅ
- ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ์ด ์ฐ์์ ์ด๋ผ ์บ์ ํจ์จ์ด ๋์
โ ๋จ์
- ์ซ์ ๋ฒ์ ์ ํ
- int[] numCnt = new int[1000]; ์ฒ๋ผ ๋ฏธ๋ฆฌ ๋ฒ์๋ฅผ ์์์ผ ํจ
- ๋ง์ฝ ์ ๋ ฅ๊ฐ์ด 10000์ด๋ ์์๋ผ๋ฉด ์ฝ๋ ์์ ํ์
- ํ์ฅ์ฑ ๋ถ์กฑ
- ๋ฐ์ดํฐ ํฌ๊ธฐ๋ ๋ฒ์๊ฐ ๊ฐ๋ณ์ ์ด๋ฉด ์ฝ๋ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์
- ์๋ฏธ ํด์์ด ์ด๋ ค์
- numCnt[์ซ์]++ ๊ตฌ์กฐ๋ ์ด๋ณด์์๊ฒ ์ง๊ด์ ์ด์ง ์์ ์ ์์
๐ก 2๏ธโฃ HashMap ๊ธฐ๋ฐ ํ์ด
import java.util.*;
class Solution {
public int solution(int[] array) {
Map<Integer, Integer> cntMap = new HashMap<>();
// ๊ฐ ์ซ์์ ๋น๋ ์ธ๊ธฐ
for (int num : array) {
cntMap.put(num, cntMap.getOrDefault(num, 0) + 1);
}
int highestValue = -1;
int highestIndex = -1;
boolean flag = false;
// ์ต๋น๊ฐ ์ฐพ๊ธฐ
for (Map.Entry<Integer, Integer> entry : cntMap.entrySet()) {
if (entry.getValue() > highestValue) {
highestValue = entry.getValue();
highestIndex = entry.getKey();
flag = false;
} else if (entry.getValue() == highestValue) {
flag = true;
}
}
return flag ? -1 : highestIndex;
}
}
โ ์ฅ์
- ๋ฒ์ ์ ํ ์์
- ์ซ์์ ํฌ๊ธฐ๊ฐ ์ปค๋, ์์์ฌ๋, ์ค๋ณต์ด ๋ง์๋ ๋ฌธ์ ์์
- ๊ฐ๋
์ฑ ์ข์
- cntMap.getOrDefault(num, 0) ๋ฑ ์๋ฐ์ค๋ฝ๊ณ ์๋ฏธ๊ฐ ๋ช ํ
- ์ ์ฐํ ํ์ฅ์ฑ
- ๋ฌธ์์ด, ์์, ๊ฐ์ฒด ๋ฑ ์ด๋ค ํ์ ์ผ๋ก๋ ํ์ฅ ๊ฐ๋ฅ
- ์ดํ ์ ๋ ฌ์ด๋ ๋ค๋ฅธ ํต๊ณ ์ฒ๋ฆฌ๋ ์ฝ๊ฒ ์ถ๊ฐ ๊ฐ๋ฅ
โ ๋จ์
- ์๋์ ์ผ๋ก ๋๋ฆผ
- HashMap์ ํด์ ์ฐ์ฐ ๋ฐ ์คํ ๋ฐ์ฑ ๋น์ฉ์ด ์์
- ์๊ฐ ๋ณต์ก๋: O(N) (ํ๊ท ), ๋จ ํด์์ถฉ๋ ์ O(N^2)๊น์ง ๊ฐ๋ฅ
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฆ๊ฐ
- ๊ฐ์ฒด ๊ตฌ์กฐ(HashMap Entry ๋ฑ)๋ก ์ธํด ๋ฐฐ์ด๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น
- ๋น๊ต์ ๋ณต์กํ ๊ตฌ๋ฌธ
- ์ด๋ณด์ ์ ์ฅ์์ entrySet()์ด๋ getOrDefault()๊ฐ ์์ํ ์ ์์
โ๏ธ 3๏ธโฃ ๋ ์ฝ๋์ ๋น๊ต
๊ตฌ๋ถ๋ฐฐ์ด ๊ธฐ๋ฐHashMap ๊ธฐ๋ฐ
| ์๊ฐ ๋ณต์ก๋ | O(N + K) (์์๋ฐฐ ๋น ๋ฆ) | O(N) (ํ๊ท ) |
| ๊ณต๊ฐ ๋ณต์ก๋ | O(K) (1000๊ฐ ๊ณ ์ ) | O(N) (์ ๋ ฅ ํฌ๊ธฐ๋งํผ) |
| ์ ๋ ฅ ๋ฒ์ ์ ํ | ์์ (0~999 ๊ฐ์ ) | ์์ |
| ๊ฐ๋ ์ฑ | ์ค๊ฐ (index ์ง์ ๊ด๋ฆฌ) | ๋์ (๋ช ์์ ๊ตฌ์กฐ) |
| ํ์ฅ์ฑ | ๋ฎ์ | ๋์ |
| ๋ฉ๋ชจ๋ฆฌ ํจ์จ | ์ข์ | ๋์จ |
| ์ฝํ ์ ํฉ๋ | โ ๋น ๋ฅด๊ณ ๋จ์ (์ ํฉ) | โช ์ ์ฐํ์ง๋ง ์ด์ง ๋ฌด๊ฒ์ |
๐งพ 4๏ธโฃ ํ๊ฐ ๋ฐ ๊ฒฐ๋ก
์ํฉ์ถ์ฒ ๋ฐฉ์
| โ ์ ๋ ฅ๊ฐ์ด ์๊ณ ๋ฒ์๊ฐ ์ ํด์ ธ ์์ | ๋ฐฐ์ด ๊ธฐ๋ฐ์ด ์๋์ ์ผ๋ก ๋น ๋ฆ |
| โ๏ธ ์ ๋ ฅ๊ฐ์ด ํด ์๋ ์๊ณ ๋ฒ์๋ฅผ ๋ชจ๋ฆ | HashMap ๊ธฐ๋ฐ์ด ์์ ํ๊ณ ์ ์ง๋ณด์ ์ฉ์ด |
| ๐ ์ฝ๋ฉํ ์คํธ ๋ฌธ์ | ๋ฐฐ์ด ๊ธฐ๋ฐ (์ฑ๋ฅ ์ค์ฌ) |
| ๐งฉ ์ค๋ฌด/ํ๋ก์ ํธ ์ฝ๋ | HashMap ๊ธฐ๋ฐ (๊ฐ๋ ์ฑ ์ค์ฌ) |
โจ ๊ฒฐ๋ก ์์ฝ
๐น ๋ฐฐ์ด ๊ธฐ๋ฐ ์ฝ๋๋ “์๊ณ ํ์คํ ์ ๋ ฅ”์ผ ๋ ์ต๊ณ ํจ์จ์ ๋ธ๋ค.
๐น HashMap ๊ธฐ๋ฐ ์ฝ๋๋ “์ ์ฐํ๊ณ ๋ฒ์๊ฐ ๋ถํ์คํ ์ ๋ ฅ”์ ๊ฐํ๋ค.
๐น **์ฑ๋ฅ ์ค์ฌ(์ฝํ )**์ด๋ผ๋ฉด ๋ฐฐ์ด,
๐น **์ ์ง๋ณด์ ์ค์ฌ(์ค๋ฌด)**์ด๋ผ๋ฉด HashMap์ ์ ํํ์.
๐ฌ Tip:
๋ง์ฝ ์ซ์ ๋ฒ์๋ฅผ ๋ชจ๋ฅธ๋ค๋ฉด,
HashMap์ผ๋ก ์์ฑํ ๋ค ์ฑ๋ฅ์ด ์ค์ํด์ง๋ ์ํฉ์์๋ง ๋ฐฐ์ด๋ก ์ต์ ํํ๋ ๊ฒ์ด ๋ฒ ์คํธ ์ ๋ต์ ๋๋ค.