https://school.programmers.co.kr/learn/challenges?tab=algorithm_practice_kit
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
ํธ๋ ๋์ ์ฌ๊ณ ๊ณผ์ ๋ฐ ๊ฐ์ ์
import java.util.*;
class Solution {
public int solution(int[] nums) {
int answer = 0;
TreeSet<Integer> ts = new TreeSet();
for(int i: nums){
ts.add(i); // ์ผ๋จ ์ด๋ฌ๋ฉด ์ค๋ณต์ ๊ฑฐ๊ฐ ๋๋ค
}
if(ts.size() >= nums.length/2){
answer = nums.length/2;
}else{
answer = ts.size();
}
return answer;
}
}
๋ถ๋ฅ๋ Hash๋ค. TreeSet์ผ๋ก ์ค๋ณต์ ๊ฑฐํด์ ์ต๋ ๊ฐ์ง์๋ฅผ ๋ฝ์๋ค.
ํด์๋ก ๋ถ๋ฅ๋ ์ด์ ๋ Set ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด์ ํธ๋ ๊ฒ ๋๋ฌธ์ผ ๊ฒ์ผ๋ก ์ถ์ ๋๋ค..
# ์ถ๊ฐ ๊ณต๋ถ
TreeSet ์๋ฃ๊ตฌ์กฐ
import java.util.*;
TreeSet<Integer> ts = new TreeSet<Integer>();
TreeSet<Integer> tsInit = new TreeSet<>(Arrays.asList(1,2,3,3,3));
ts.add(1);
ts.add(2);
ts.add(2);
ts.add(3);
ts.remove(2);
ts.size(); // ํฌ๊ธฐ
ts.clear(); // ์ ์ฒด ๋ ๋ฆฌ๊ธฐ
Treeset์ ๊ธฐ๋ณธ์ผ๋ก ๋ ๋๋ธ๋ํธ๋ฆฌ๊ฐ ์ ์ฉ๋์ด์๋ Set ์๋ฃ๊ตฌ์กฐ๋ค.
https://ko.wikipedia.org/wiki/%EB%A0%88%EB%93%9C-%EB%B8%94%EB%9E%99_%ED%8A%B8%EB%A6%AC
๋ ๋-๋ธ๋ ํธ๋ฆฌ - ์ํค๋ฐฑ๊ณผ, ์ฐ๋ฆฌ ๋ชจ๋์ ๋ฐฑ๊ณผ์ฌ์
์ํค๋ฐฑ๊ณผ, ์ฐ๋ฆฌ ๋ชจ๋์ ๋ฐฑ๊ณผ์ฌ์ . ๋ ๋-๋ธ๋ ํธ๋ฆฌ(red-black tree)๋ ์๊ฐ ๊ท ํ ์ด์ง ํ์ ํธ๋ฆฌ(self-balancing binary search tree)๋ก์, ๋ํ์ ์ผ๋ก๋ ์ฐ๊ด ๋ฐฐ์ด ๋ฑ์ ๊ตฌํํ๋ ๋ฐ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ๋ค. 1978๋
ko.wikipedia.org
๋ ๋๋ธ๋ํธ๋ฆฌ๋ ๋ถ๋ชจ๋ ธ๋ ๊ธฐ์ค์ผ๋ก ์์๊ฒ ์ผ์ชฝ์ผ๋ก, ํฐ๊ฒ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ค. ๊ทธ๋์ ts.first()๋ ํธ๋ฆฌ์์ ๊ฐ์ฅ ์์ ๊ฐ, ts.last()๋ ํธ๋ฆฌ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ค. ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด ๊ธฐ๋ณธ์ด๋ผ๊ณ ํ ์ ์๋ค.
๊ทธ๋์ ๊ทธ๋ฅ new ๋ก ๋ง๋๋๊ฒ ์๋๋ผ Collections.reverseOrder() ํด์ฃผ๋ฉด ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด ๋๋ TreeSet์ด ์์ฑ๋๋ค.
TreeSet<Integer> ts = new TreeSet(Comparator.reverseOrder());
Collection์ธ๋ฐ, Set๊ตฌ์กฐ๋ผ ์ํ๊ฐ ์ข ๋ถํธํ๋ค. Iterator๋ก ๊ฐ์ธ์ ์ํํด์ผ๋๋ค.
Iterator it = ts.iterator();
while(iter.hasNext()){
System.out.print(it.next() + "\n");
}
์ ๋ ฌ๋ ์์๋๋ก iterator๊ฐ ์ํํ๋ค.
HashSet์ ์ฐ๋ฉด ์์๊ฐ ์ ๋ ฌ๋์ง์์์์ง๋ง ํด์ํ ์ด๋ธ์ ์ฌ์ฉํด์ O(1)์ ์๋๋ฅผ ์๋ํ๋ค. ๊ทผ๋ฐ TreeSet์ ์ฐ๋ฉด ์ ๋ ฌ๋์ด์์ด์ ๋ง์ฝ ๋ฒ์๊ฒ์ ๊ฐ์ ๊ฒ ํ์ํ๋ฉด ์ด๊ฑธ ์จ์ผ๋๋ค. O(logN)์ด๊ฑฐ๋ amortized O(1)์ด๊ธฐ ๋๋ฌธ์ ์ ๋ ฅ์ด ์ ๋ ฅ์ด ์์ฒญ ์ปค์ ์กฐํ์ ์๊ฐ์ด ๋ง ๊ฑธ๋ฆฌ๋ ๊ฒ ์๋๋ผ๋ฉด TreeSet์ ์จ๋ ๋ ๊ฒ ๊ฐ๋ค.
๋ฒ์๊ฒ์์ headSet, tailSet์ ์ด๋ค. ์ด๊ฒ ์ ์ธ๊ณ๋ค.
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
numbers.add(6);
// headSet() ์์
System.out.println("headSet(4): " + numbers.headSet(4));
System.out.println("headSet(4, true): " + numbers.headSet(4, true));
// tailSet() ์์
System.out.println("tailSet(4): " + numbers.tailSet(4));
System.out.println("tailSet(4, false): " + numbers.tailSet(4, false));
headSet์ ์ฃผ์ด์ง ์์๋ณด๋ค ์์ ๋ฒ์์ ๋ถ๋ถ์งํฉ์ ๋ฐํํ๋ค. ์์๋ฅผ ํฌํจํ๊ณ ์ถ์ผ๋ฉด true๋ฅผ ๊ฐ์ด ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
tailSet์ ์ฃผ์ด์ง ์์๋ณด๊ฐ ํฌ๊ฑฐ๋ ๊ฐ์ ๋ฒ์์ ๋ถ๋ถ์งํฉ์ ๋ฐํํ๋ค. ๊ทธ๋์ ์์๊ฐ ํฌํจ๋์ด์๋๋ฐ, false๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ์์ ์ ์ด ์ ์ธ๋๋ค.
๋์์ด ๋๋ค๋ฉด ๋๊ธ์ด๋ ๊ณต๊ฐ ๋ฒํผ ํ ๋ฒ์ฉ ๋๋ฅด๊ณ ๊ฐ์ฃผ์ธ์!
'OJ๐ผ > Programmers ๊ณ ๋์ ํท' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[LV.2][JAVA] ์ฌ๋ฐ๋ฅธ ๊ดํธ (0) | 2024.08.28 |
---|---|
[LV.3][JAVA] ๋ฒ ์คํธ ์จ๋ฒ (0) | 2024.08.27 |
[LV.2][JAVA] ๋ ๋งต๊ฒ (0) | 2024.08.27 |
[LV.2][JAVA] ์ ํ๋ฒํธ ๋ชฉ๋ก (0) | 2024.08.25 |
[LV.1][JAVA] ์์ฃผํ์ง ๋ชปํ ์ ์(feat. TreeMap) (0) | 2024.08.25 |