2023. 10. 25. 15:23ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1230
-> ์ด์ ๋ฌธ์ ํ์ด
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
๋ฌธ์ ํ์ด 1
public int solution(int n, int k, int[] arr) {
int answer;
Set<Integer> set = new TreeSet<>();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int x = j + 1; x < n; x++) {
set.add(arr[i] + arr[j] + arr[x]);
}
}
}
if (set.size() < k) {
return -1;
}
answer = set.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()).get(k - 1);
return answer;
}
๐ฉ๐ป๐ป : ์ด ๋ฌธ์ ๋ n ๊ฐ์ ์นด๋๊ฐ ์ฃผ์ด์ง๋๋ฐ ์ด ์นด๋ 3๊ฐ๋ฅผ ๋ฝ์์ ๋ํ๋๋ฐ ์ด๋ ๋์ฌ ์ ์๋ ๊ฐ๋ค์ ๋ชจ๋ ๊ตฌํ ๋ค์
K ๋ฒ์งธ ํฐ ์์ ๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค. (์ด๋ ์ค๋ณต๋ ๊ฐ์ ์ ์ธํ๊ณ K๋ฒ์งธ ์์ด๋ฏ๋ก ์ค๋ณต ์ ๊ฑฐ๋ฅผ ์ด์ฉํด์ผ ํ๋ค.)
์ค๋ณต ์ ๊ฑฐ๋ฅผ ํ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ๊ฐ Set ์ด๋ค. Set์ ์ค๋ณต์ ํ์ฉํ์ง ์๊ณ , ์์ ์ ์ง๋ฅผ ํ์ง ์๋๋ฐ
์ฌ๊ธฐ์ ํฐ ์๋ก ์ ๋ ฌํด์ ๋ํ๊ณ ์ถ๋ค๋ฉด TreeSet ์ ์ด์ฉํ๋ฉด ๋๋ค.
์ผ์ค for ๋ฌธ์ ์ด์ฉํด์ arr[i] + arr[j] + arr[x] ์ ํฉ์ set์ add ํด์ฃผ๊ณ ,
k ๊ฐ set์ ํฌ๊ธฐ๋ณด๋ค ํฌ๋ฉด ์๋ค๋ ๊ฒ์ด๋ฏ๋ก -1 ๋ฅผ ๋ฆฌํดํด์ค๋ค.
TreeSet ์ add ํ ๊ฐ์ด ์ค๋ฆ์ฐจ์์ด๋๊น ๋ด๋ฆผ์ฐจ์์ ๋ง๋ค์ด์ค์ผํ๋๋ฐ... ๋๋ new TreeSet<> (Collections.reverseOrder()); ์ ๋ชฐ๋ผ์.. ^^ ์๊ฐ๋ฌ๋ stream.sorted ์ฌ์ฉ ํ, Comparator.reverseOrder()๋ฅผ ์ฌ์ฉํด์คฌ๋ค..
๊ทธ ๋ค์ Stream์ด๋ฏ๋ก List ํํ๋ก ๋ฐ๊พผ๋ค์ get(k-1) ์ ํด์ answer ๊ฐ์ ๊ตฌํ๋ค. (k-1) ๋ฒ์งธ๋ถํฐ ํ ์ด์ ๋ 0 ๋ถํฐ get ํ๊ธฐ ๋๋ฌธ !~
-> ์ด ๋ถ๋ถ์ ์ฝ๊ฐ์ ๋ป์ง์ด ๋ค์ด๊ฐ ๋ถ๋ถ์ด๋ค...
๋ฌธ์ ํ์ด 2
public int solution2(int[] arr, int n, int k) {
int answer = -1;
TreeSet<Integer> treeSet = new TreeSet<>(Collections.reverseOrder());
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int l = j + 1; l < n; l++) {
treeSet.add(arr[i] + arr[j] + arr[l]);
}
}
}
int cnt = 0;
for (Integer integer : treeSet) {
cnt++;
if (cnt == k) return integer;
}
return answer;
}
๐พ : ์ผ์ค for๋ฌธ์ผ๋ก treeSet์ ์ธ๊ฐ์ ํฉ์ ๊ตฌํด์ addํ๋ ๊ฑด ๋๊ฐ์๋ฐ TreeSet์ ์์ฑํ ๋ Collections.reverseOrder()๋ฅผ ์ด์ฉํ๋ฉด ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ์ค๋ณต ์ ๊ฑฐํด์ ์ ์ฅํด์ค๋ค..!
๊ทธ ๋ค์ cnt ๋ณ์๋ฅผ ํ๋ ์ ์ธํด์ cnt +1 ํ๋ฉด์ treeSet์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ฐ์ ๊ตฌํ๋๋ฐ cnt ๊ฐ์ด k ๊ฐ์ด ๋๋ฉด ๊ทธ ๊ฐ์ return ํด์ฃผ๋๋ก ํ๋ค.
๋ง์ฝ ์ด ๋ฐ๋ณต๋ฌธ์ ๋์ด์๋ k ๊ฐ์ ๊ตฌํ์ง ๋ชปํ๋ค๋ฉด ๊ธฐ๋ณธ answer ๋ฅผ -1๋ก ์ด๊ธฐํํด์คฌ๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก ๋ฆฌํดํด์ฃผ๋ฉด ๋๋ค.
<TreeSet์ ๋ฉ์๋>
public void solution3(int[] arr, int n, int k) {
TreeSet<Integer> treeSet = new TreeSet<>(Collections.reverseOrder());
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int l = j + 1; l < n; l++) {
treeSet.add(arr[i] + arr[j] + arr[l]);
}
}
}
System.out.println("treeSet.size() = " + treeSet.size());
treeSet.remove(143);
System.out.println("treeSet.size() = " + treeSet.size());
System.out.println("treeSet = " + treeSet);
System.out.println("treeSet.first() = " + treeSet.first()); // ์ ์ผ ์์ ์๋ฅผ ์ถ๋ ฅ
System.out.println("treeSet.last() = " + treeSet.last()); // ์ ์ผ ๋ง์ง๋ง์ ์๋ฅผ ์ถ๋ ฅ
}
treeSet.size() : TreeSet์ ํฌ๊ธฐ๋ฅผ ๊ตฌํ๋ ๋ฉ์๋
treeSet.remove() : ์ฃผ์ด์ง ๊ฐ์ TreeSet์์ ์ ๊ฑฐํ๋ ๋ฉ์๋
treeSet.first() : treeSet์ ์ ์ผ ์์ ์๋ฅผ ์ถ๋ ฅ
treeSet.last() : treeSet์ ์ ์ผ ๋ง์ง๋ง ์๋ฅผ ์ถ๋ ฅ
๊ฒฐ๊ณผ
treeSet.size() = 72
treeSet.size() = 71
treeSet = [152, 144, 141, 140, 136, 133, 132, 130, 125, 124, 123, 122, 121, 120, 118, 114, 113, 112, 111, 110, 109, 106, 105, 104, 103, 102, 101, 100, 99, 98, 94, 93, 92, 91, 90, 89, 88, 87, 86, 84, 83, 82, 81, 80, 79, 78, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 64, 62, 61, 60, 59, 58, 57, 54, 52, 51, 50, 49, 47, 39]
treeSet.first() = 152
treeSet.last() = 39