ํ๋ก์ธ์ค(with. Java)
ํ๋ก์ธ์ค(with. Java)์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
์ด์์ฒด์ ์ ์ญํ ์ค ํ๋๋ ์ปดํจํฐ ์์คํ ์ ์์์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๋ ๊ฒ์ ๋๋ค.
์ด ๋ฌธ์ ์์๋ ์ด์์ฒด์ ๊ฐ ๋ค์ ๊ท์น์ ๋ฐ๋ผ ํ๋ก์ธ์ค๋ฅผ ๊ด๋ฆฌํ ๊ฒฝ์ฐ ํน์ ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์์๋ด๋ฉด ๋ฉ๋๋ค.
- ์คํ ๋๊ธฐ ํ(Queue)์์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ํ๋๋ฅผ ๊บผ๋ ๋๋ค.
- ํ์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ์ค ์ฐ์ ์์๊ฐ ๋ ๋์ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ๋ค์ ํ์ ๋ฃ์ต๋๋ค.
- ๋ง์ฝ ๊ทธ๋ฐ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ์คํํฉ๋๋ค. 3.1 ํ ๋ฒ ์คํํ ํ๋ก์ธ์ค๋ ๋ค์ ํ์ ๋ฃ์ง ์๊ณ ๊ทธ๋๋ก ์ข ๋ฃ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ํ๋ก์ธ์ค 4๊ฐ [A, B, C, D]๊ฐ ์์๋๋ก ์คํ ๋๊ธฐ ํ์ ๋ค์ด์๊ณ , ์ฐ์ ์์๊ฐ [2, 1, 3, 2]๋ผ๋ฉด [C, D, A, B] ์์ผ๋ก ์คํํ๊ฒ ๋ฉ๋๋ค.
ํ์ฌ ์คํ ๋๊ธฐ ํ(Queue)์ ์๋ ํ๋ก์ธ์ค์ ์ค์๋๊ฐ ์์๋๋ก ๋ด๊ธด ๋ฐฐ์ด priorities์, ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์๊ณ ์ถ์ ํ๋ก์ธ์ค์ ์์น๋ฅผ ์๋ ค์ฃผ๋ location์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํด๋น ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- priorities์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- priorities์ ์์๋ 1 ์ด์ 9 ์ดํ์ ์ ์์ ๋๋ค.
- priorities์ ์์๋ ์ฐ์ ์์๋ฅผ ๋ํ๋ด๋ฉฐ ์ซ์๊ฐ ํด ์๋ก ์ฐ์ ์์๊ฐ ๋์ต๋๋ค.
- location์ 0 ์ด์ (๋๊ธฐ ํ์ ์๋ ํ๋ก์ธ์ค ์ - 1) ์ดํ์ ๊ฐ์ ๊ฐ์ง๋๋ค.
- priorities์ ๊ฐ์ฅ ์์ ์์ผ๋ฉด 0, ๋ ๋ฒ์งธ์ ์์ผ๋ฉด 1 โฆ ๊ณผ ๊ฐ์ด ํํํฉ๋๋ค.
์ ์ถ๋ ฅ ์
priorities | location | return |
---|---|---|
[2, 1, 3, 2] | 2 | 1 |
[1, 1, 9, 1, 1, 1] | 0 | 5 |
๋ฌธ์ ํ์ด
import java.util.Queue;
import java.util.LinkedList;
import java.util.Collections;
import java.util.Arrays;
class Solution {
public int solution(int[] priorities, int location) {
int answer = 0;
Queue<Integer> queue = new LinkedList<>();
int want_num = priorities[location];
int count = 0;
for(int i : priorities){
queue.offer(i);
if(want_num <= i){
count++;
}
}
if(count == 0){
return 1;
}
Integer[] arr = Arrays.stream(priorities).boxed().toArray(Integer[]::new);
Arrays.sort(arr, Collections.reverseOrder());
int idx = 0;
while(!queue.isEmpty()){
int temp = 0;
if(queue.peek() == arr[idx]){
answer++;
idx++;
queue.poll();
if(location == 0){
break;
}
location--;
}else{
temp = queue.poll();
queue.offer(temp);
location--;
if(location < 0){
location = queue.size() - 1;
}
}
}
return answer;
}
}
ํ์ด ์ค๋ช
์ด ์ฝ๋๋ ํ๋ฆฐํฐ์ ์์ ์ฐ์ ์์๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค.
์ฃผ์ด์ง ์์ ์ฐ์ ์์ ๋ฐฐ์ด๊ณผ ํน์ ์์น์ ์์ ์ด ๋ช ๋ฒ์งธ๋ก ์ถ๋ ฅ๋๋์ง๋ฅผ ๊ณ์ฐํ๋ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํฉ๋๋ค.
์ฝ๋ ํด์ค
ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํฌํธ
Queue, LinkedList, Collections, Arrays ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
๋ฉ์๋ ์ ์
solution ๋ฉ์๋๋ฅผ ์ ์ํ๊ณ , int[] priorities์ int location์ ์ ๋ ฅ์ผ๋ก ๋ฐ์ต๋๋ค.
๋ณ์ answer๋ฅผ ์ด๊ธฐํํฉ๋๋ค.
์ด๋ ์ต์ข ์ ์ผ๋ก ๋ฐํํ ๊ฐ์ผ๋ก, ํน์ ์์ ์ด ๋ช ๋ฒ์งธ๋ก ์ถ๋ ฅ๋๋์ง๋ฅผ ๋ํ๋ ๋๋ค.
ํ ์ด๊ธฐํ
Queue
location ์์น์ ์ฐ์ ์์๋ฅผ want_num ๋ณ์์ ์ ์ฅํฉ๋๋ค.
priorities ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ํ์ ์ฝ์ ํ๋ฉด์, want_num๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ์์์ ๊ฐ์๋ฅผ count ๋ณ์์ ์ ์ฅํฉ๋๋ค.
๋ง์ฝ count๊ฐ 0์ด๋ฉด, ์ด๋ want_num์ด ๊ฐ์ฅ ๋์ ์ฐ์ ์์์์ ์๋ฏธํ๋ฏ๋ก 1์ ๋ฐํํฉ๋๋ค.
์ฐ์ ์์ ๋ฐฐ์ด ์ ๋ ฌ
priorities ๋ฐฐ์ด์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ arr ๋ฐฐ์ด์ ์ ์ฅํฉ๋๋ค. ์ด๋ฅผ ํตํด ๊ฐ์ฅ ๋์ ์ฐ์ ์์๋ถํฐ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
์์ ์์ ๊ณ์ฐ
์ ๋ ฌ๋ ๋ฐฐ์ด arr์ ์์์ ํ์ ์ ์์๋ฅผ ๋น๊ตํ๋ฉด์ ์์๋๋ก ์ฒ๋ฆฌํฉ๋๋ค.
ํ์ ์ ์์๊ฐ ํ์ฌ ์ฒ๋ฆฌํ ์ฐ์ ์์์ ๊ฐ์ผ๋ฉด answer๋ฅผ ์ฆ๊ฐ์ํค๊ณ , ํ์์ ํด๋น ์์๋ฅผ ์ ๊ฑฐํฉ๋๋ค.
location์ด 0์ด๋ฉด, ์ด๋ ์ฐ๋ฆฌ๊ฐ ์ฐพ๋ ์์ ์ด๋ฏ๋ก ๋ฃจํ๋ฅผ ์ข ๋ฃํฉ๋๋ค.
ํ์ ์ ์์๊ฐ ํ์ฌ ์ฒ๋ฆฌํ ์ฐ์ ์์์ ๋ค๋ฅด๋ฉด ํ์ ์ ์์๋ฅผ ๋ค๋ก ๋ณด๋ด๊ณ , location ๊ฐ์ ์กฐ์ ํฉ๋๋ค.
location์ด 0 ๋ฏธ๋ง์ด ๋๋ฉด ํ์ ๋ง์ง๋ง์ผ๋ก ์ด๋ํฉ๋๋ค.
๊ฒฐ๊ณผ ๋ฐํ
answer๋ฅผ ๋ฐํํ์ฌ ํน์ ์์ ์ด ๋ช ๋ฒ์งธ๋ก ์ถ๋ ฅ๋๋์ง๋ฅผ ๋ฐํํฉ๋๋ค.
์์ ์ ๋ ฅ
์๋ฅผ ๋ค์ด, priorities๊ฐ [2, 1, 3, 2]์ด๊ณ location์ด 2๋ผ๋ฉด, ์ถ๋ ฅ๋๋ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
3 (์์น 2, ์ฒซ ๋ฒ์งธ ์ถ๋ ฅ)
2 (์์น 0, ๋ ๋ฒ์งธ ์ถ๋ ฅ)
2 (์์น 3, ์ธ ๋ฒ์งธ ์ถ๋ ฅ)
1 (์์น 1, ๋ค ๋ฒ์งธ ์ถ๋ ฅ)
location์ด 2์ธ ์์ ์ ์ฒซ ๋ฒ์งธ๋ก ์ถ๋ ฅ๋๋ฏ๋ก, ๊ฒฐ๊ณผ๋ 1์ ๋๋ค.