[TreeSet] 5. K๋ฒ์งธ ํฐ ์
์ค๋ช
ํ์๋ 1๋ถํฐ 100์ฌ์ด์ ์์ฐ์๊ฐ ์ ํ N์ฅ์ ์นด๋๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๊ฐ์ ์ซ์์ ์นด๋๊ฐ ์ฌ๋ฌ์ฅ ์์ ์ ์์ต๋๋ค.
ํ์๋ ์ด ์ค 3์ฅ์ ๋ฝ์ ๊ฐ ์นด๋์ ์ ํ ์๋ฅผ ํฉํ ๊ฐ์ ๊ธฐ๋กํ๋ ค๊ณ ํฉ๋๋ค. 3์ฅ์ ๋ฝ์ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๊ธฐ๋กํฉ๋๋ค.
๊ธฐ๋กํ ๊ฐ ์ค K๋ฒ์งธ๋ก ํฐ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
๋ง์ฝ ํฐ ์๋ถํฐ ๋ง๋ค์ด์ง ์๊ฐ 25 25 23 23 22 20 19......์ด๊ณ K๊ฐ์ด 3์ด๋ผ๋ฉด K๋ฒ์งธ ํฐ ๊ฐ์ 22์ ๋๋ค.
์ ๋ ฅ
์ฒซ ์ค์ ์์ฐ์ N(3<=N<=100)๊ณผ K(1<=K<=50) ์ ๋ ฅ๋๊ณ , ๊ทธ ๋ค์ ์ค์ N๊ฐ์ ์นด๋๊ฐ์ด ์ ๋ ฅ๋๋ค.
์ถ๋ ฅ
์ฒซ ์ค์ K๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค. K๋ฒ์งธ ์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด -1๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ 1
10 3
13 15 34 23 45 65 33 11 26 42
์์ ์ถ๋ ฅ 1
143
<<ํ์ด>>
์ผ๋จ ์ด ๋ฌธ์ ๋ ์ผ์ค for๋ฌธ ์ฌ์ฉํ๋ฉด ๋ฐ๋ก ๊ตฌํ ์ ์๋ค.
ํ์ง๋ง ์ผ์ค for๋ฌธ ๋ง๊ณ ๋ฅผ ์๊ฐํ๋ค๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ๋ฅผ ์๊ฐ ํด๋ดค๋๋ฐ ใ ใ
๊ฐ์ฌ๋๋ ์ผ์ค for๋ฌธ์ ์ฌ์ฉํ๋ค๊ณ ํ๋ค ใ ใ ๊ทธ๋์ ๋๋ ์ผ์ค for๋ฌธ์ ํ์ฉํ๊ณ ํด์ฌ๋งต์ ์ฌ์ฉํด์ ๋ฃ์ ๋ค์
๊ทธ ๊ฐ์ ๋ค์ keySet ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ํ๊ณ ์ ๋ ฌ ๋๋ for๋ฌธ์ ์ฌ์ฉํด์ ํ ์์ ์ด์๋ค.
๋ค๋ง!
์ด๋ฒ์๋
์ค๋ณต์ ๊ฑฐ์ ์ ๋ ฌ๊น์ง ํด์ฃผ๋ TreeSet ์ ํ์ฉํด์ ํ์๋ค.
-๊ฐ์ฌ๋ ํ์ด-
import java.util.Collections;
import java.util.Scanner;
import java.util.TreeSet;
class Main {
private int solution(int[] arr, int n, int m) {
int answer = -1;
TreeSet<Integer> Tset = new TreeSet<>(Collections.reverseOrder());
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
Tset.add(arr[i] + arr[j] + arr[k]);
}
}
}
int cnt = 0;
for (int x : Tset) {
cnt++;
if (cnt == m) return x;
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = in.nextInt();
}
System.out.println(T.solution(arr, n, m));
}
}
์ด๋ ๊ฒ TreeSet์ ํ์ฉํ๋ฉด HashMap์ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋ ๊ฐํธํ๊ฒ ๊ตฌํ ์ ์์๋ค.
<<์ถ๊ฐ ํ์ด>>
TreeSet์ ๋ฉ์๋
add() -> ๊ฐ์ ๋ฃ๋๋ค.
remove() -> ๋ค์ด์๋ ํน์ ๊ฐ์ ์ ๊ฑฐํ๋ค.
size() -> ์์์ ๊ฐฏ์๋ฅผ ๊ตฌํ ์ ์๋ค.
first() -> ์ค๋ฆ์ฐจ์์ผ ๋์๋ ์ต์๊ฐ์ ๋ฐํํ๊ณ ๋ด๋ฆผ์ฐจ์์ผ ๋๋ ์ต๋๊ฐ์ ๋ฐํํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ ์ผ ์ฒซ๋ฒ์งธ ์ธ์๋ฅผ ๋ฐํํ๋ค.
last() -> fisrt์ ๋ฐ๋์ด๋ค.
isEmpty() -> ์์ ๊ฐ์ด ์์ผ๋ฉด false ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค.
TreeSet<Integer> Tset = new TreeSet<>(Collections.reverseOrder());
Collections.reverseOrder() -> ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
์ด๊ฑฐ ์์ด ๊ทธ๋ฅ
TreeSet<Integer> Tset = new TreeSet<>();
๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
์ค๋๋ ์ ๋๋ก ๋ฐฐ์ฐ๊ณ ๊ฐ๋ค!!
'์ฝ๋ฉํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์คํ] 2. ๊ดํธ๋ฌธ์์ ๊ฑฐ (1) | 2024.01.08 |
---|---|
[์คํ] 1. ์ฌ๋ฐ๋ฅธ ๊ดํธ (0) | 2024.01.07 |
[ํด์ฌ, ํฌํฌ์ธํฐ, ์ฌ๋ผ์ด๋ฉ] 4. ๋ชจ๋ ์๋๊ทธ๋จ ์ฐพ๊ธฐ (0) | 2024.01.06 |
[ํด์ฌ๋งต ์ฌ๋ผ์ด๋ฉ] 3. ๋งค์ถ์ก์ ์ข ๋ฅ (1) | 2024.01.04 |
[HashMap] 2. ์๋๊ทธ๋จ (1) | 2023.12.31 |
๋๊ธ