๐ ๋ฌธ์ ๋งํฌ
๐ ๋ฌธ์ ํ์ด
์ฌ์ ๋ณด์ด๋ฉด์๋ ์๊ทผํ ํธ๋๋ฐ ์ค๋ ๊ฑธ๋ ธ๋ค ,,
HashMap์ ์ฌ์ฉํด key๊ฐ์ ์คํ ์ด์ง ๋ฒํธ, value๊ฐ์ ์คํจ์จ์ ์ ์ฅํ ํ ์ ๋ ฌํ๋ฉด ๋๊ฒ ๋ค๋ ์๊ฐ์ ํ๋ค.
HashMap ์ ๋ ฌ์ ๋ํด ๊ตฌ๊ธ๋ง ํด๋ณด๋ map์ keySet์ ์ด์ฉํด ์ ๋ ฌ์ด ๊ฐ๋ฅํ ๊ฒ์ ์๊ฒ ๋์๋ค.
[Java] Map์ Key, Value๋ก ์ ๋ ฌํ๊ธฐ
Java์์ HashMap ์ ๋ ฌ์ด ํ์ํ ๋, ๊ทธ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณผ ๊ฒ์ด๋ค.์ ๋ ฌ ๊ธฐ์ค์ key, value ๋๊ฐ์ง๋ก ๋๋ ์ ์๋ค.map ์ keySet์ ์ด์ฉํ์ฌ ์ ๋ ฌํ๋ค.์ค๋ฆ์ฐจ์ ์์๋ Collection.sort(), ๋ด๋ฆผ์ฐจ์ ์์๋ Col
velog.io
๊ฐ ์คํ ์ด์ง๋ง๋ค ์คํจ์จ์ ๊ตฌํ๊ธฐ ์ํด์ ์ฃผ์ด์ง ๋ฐฐ์ด stages๋ฅผ ์ฐธ๊ณ ํ์ฌ ๋ฐฐ์ด ๋ ๊ฐ๋ฅผ ๋ง๋ค์๋ค.
1) ์คํ ์ด์ง์ ๋๋ฌํ์ผ๋ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ ํ๋ ์ด์ด์ ์๋ฅผ ๋ด์ ๋ฐฐ์ด
2) ์คํ ์ด์ง์ ๋๋ฌํ ํ๋ ์ด์ด ์๋ฅผ ๋ด์ ๋ฐฐ์ด
๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ ์คํ ์ด์ง ๋ฒํธ๋ผ๊ณ ์๊ฐํ๊ณ , ๊ฐ ์คํ ์ด์ง ๋ฒํธ์ ์ผ์นํ๋ ์ธ๋ฑ์ค์ ์๋ฅผ ์ ์ฅํ๋ค.
๋ ๋ฐฐ์ด์ ๊ฐ์ ์ธ๋ฑ์ค์ ๋ค์ด์๋ ์์ ๊ฐ์ ๋๋์ด ์คํจ์จ์ ๊ณ์ฐํ๊ณ , HashMap์ ์ ์ฅํ๋ฉด ๋๋ค.
๋ง์ฝ ์คํ ์ด์ง์ ๋๋ฌํ ์ ์ ๊ฐ ์๋ ๊ฒฝ์ฐ, ์คํจ์จ์ 0์ผ๋ก ์ ์ํ๋ ์์ธ ์ฒ๋ฆฌ๋ ํด์ฃผ์ด์ผ ํ๋ค.
Key Point
๐ ๋ฐฐ์ด์ ํ์ฉํด ์คํจ์จ์ ๊ตฌํ๋ค.
๐ HashMap์ ์ฌ์ฉํด ์คํ ์ด์ง ๋ฒํธ(key)์ ์คํจ์จ(value)์ ์ ์ฅํ๋ค.
๐ ์คํ ์ด์ง์ ๋๋ฌํ ์ ์ ๊ฐ ์๋ ๊ฒฝ์ฐ(์คํจ์จ = 0)๋ฅผ ๊ณ ๋ คํ๋ค.
๐ ์คํจ์จ(value)์ ๊ธฐ์ค์ผ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ํ, ์คํ ์ด์ง ๋ฒํธ(key)๋ฅผ ๋ฐฐ์ด answer์ ๋ฃ์ด์ค๋ค.
Java ์ฝ๋
import java.util.*;
class Solution {
public int[] solution(int N, int[] stages) {
int[] answer = new int[N];
// ์คํ
์ด์ง์ ๋๋ฌํ์ผ๋ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ ํ๋ ์ด์ด ์ ์ ๋ณด๋ฅผ ๋ด์ ๋ฐฐ์ด
int[] stageCount = new int[N+2];
for (int stage : stages) {
stageCount[stage]++;
}
// ์คํ
์ด์ง์ ๋๋ฌํ ํ๋ ์ด์ด ์ ์ ๋ณด๋ฅผ ๋ด์ ๋ฐฐ์ด
int[] stagePassCount = new int[N+1];
stagePassCount[N] = stageCount[N] + stageCount[N+1];
for (int i=N-1; i>=1; i--) {
stagePassCount[i] = stageCount[i] + stagePassCount[i+1];
}
// HashMap์ ์ฌ์ฉํด ์คํจ์จ ์ ์ฅ (Key: ์คํ
์ด์ง ๋ฒํธ, value: ์คํจ์จ)
HashMap<Integer,Double> map = new HashMap<>();
for (int i=1; i<=N; i++) {
if (stagePassCount[i] == 0) {
map.put(i, (double)0);
}
else {
map.put(i, (double)stageCount[i]/stagePassCount[i]);
}
}
// ๊ฐ ์คํ
์ด์ง ๋ฒํธ(key)๋ฅผ ์คํจ์จ(value)์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ
List<Integer> keySet = new ArrayList<>(map.keySet());
keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));
int idx = 0;
for (int stage : keySet) {
answer[idx++] = stage;
}
return answer;
}
}
'Algorithms > programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Programmers, [3์ฐจ] ํ์ผ๋ช ์ ๋ ฌ : Java (2) | 2022.12.13 |
---|---|
Programmers, [3์ฐจ] N์ง์ ๊ฒ์ : Java (3) | 2022.12.12 |
Programmers, [3์ฐจ] ๋ฐฉ๊ธ๊ทธ๊ณก : Java (0) | 2022.12.08 |
Programmers, ์คํ์ฑํ ๋ฐฉ : Java (0) | 2022.12.07 |
Programmers, [1์ฐจ] ๋คํธ ๊ฒ์ : Java (0) | 2022.12.06 |