1. ๋ฌธ์ ์ค๋ช
์์ #1
๋ฌธ์ ์ ๋์จ ์์ ๊ฐ์ต๋๋ค.
์์ #2
6๊ฐ์ ํ๋ก์ธ์ค [A, B, C, D, E, F]๊ฐ ๋๊ธฐ ํ์ ์๊ณ ์ค์๋๊ฐ [1, 1, 9, 1, 1, 1] ์ด๋ฏ๋ก [C, D, E, F, A, B] ์์ผ๋ก ์คํ๋ฉ๋๋ค. ๋ฐ๋ผ์ A๋ 5๋ฒ์งธ๋ก ์คํ๋ฉ๋๋ค.
2. ์ ๊ทผ๋ฐฉ์
2-1. ๋ฐฐ์ด ์ชผ๊ฐ๊ธฐ (์ถ์ฒํ์ง ์์โ)
๋ณด์๋ง์ ์ต๋๊ฐ์ ์ฐพ์์ ์ต๋๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฐฐ์ด์ ์ชผ๊ฐ์ ๋ค์ ๋ถ์ด๋ฉด ๋ ๊ฑฐ ๊ฐ๋ค๊ณ ์๊ฐํ๋ค. priorities ๋ฐฐ์ด๋ฅผ ์ํํ๋ฉด์ ์ฐ์ ์์ max๊ฐ์ ์ฐพ๊ณ , ๊ทธ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฐฐ์ด์ ๋ ๊ฐ๋ก ์ชผ๊ฐ ๋ค์, ์ ๋ค๋ก ์ด์ด์ ๋ถ์ด๋ ๊ฒ์ด๋ค. ๋๊ฒ ์ฝ๊ฒ ํ ์ค ์์๋๋ฐ ์๊ฐ๋ณด๋ค ์ด๋ ค์ ๊ณ ์์งํ ๊ณ์ ์คํจํ๋ค. ๋ฐฐ์ด ์ชผ๊ฐ๋ ๋ฉ์๋๋ฅผ ๊ตฌ๊ธ์์ ์ฐพ์๊ฐ๋ฉด์ ์ฝ๋๋ฅผ ์ฐ๋๋ฐ ์จ ๋ด๋ ค ๊ฐ์๋ก ์ฝ๋๊ฐ ๋๋ฌด ๊ธธ์ด์ง๊ณ ์์ํ๋ค. ๊ทธ๋์ ์ด ์ฝ๋๋ ๊ต์ฅํ ๋นํจ์จ์ ์ธ ์ฝ๋๋ผ๊ณ ์๊ฐํ๋ค.
import java.util.Arrays;
class Solution {
public int solution(int[] priorities, int location) {
// 1. ์ต๋๊ฐ์ ์ธ๋ฑ์ค ์ฐพ๊ธฐ
int maxIndex = 0;
for (int i = 1; i < priorities.length; i++) {
if (priorities[i] > priorities[maxIndex]) {
maxIndex = i;
}
}
// 2. ๋ฐฐ์ด์ ์ต๋๊ฐ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋๊ธฐ
int[] firstPart = Arrays.copyOfRange(priorities, 0, maxIndex);
int[] secondPart = Arrays.copyOfRange(priorities, maxIndex, priorities.length);
// 3. ๋ฐฐ์ด์ ๋ ๋ถ๋ถ์ผ๋ก ๋๋ ๋ค ์ฌ๊ฒฐํฉ (๋ ๋ฒ์งธ ๋ถ๋ถ์ด ์์, ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์ด ๋ค์)
int[] mergedArray = new int[priorities.length];
System.arraycopy(secondPart, 0, mergedArray, 0, secondPart.length);
System.arraycopy(firstPart, 0, mergedArray, secondPart.length, firstPart.length);
// 4. ์๋ `location` ๊ฐ์ ์๋ก์ด ์ธ๋ฑ์ค ์ฐพ๊ธฐ
int newIndex = -1;
int originalValue = priorities[location];
for (int i = 0; i < mergedArray.length; i++) {
if (mergedArray[i] == originalValue) {
newIndex = i;
break; // ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ๋ก ๋์ค๋ ๊ฐ์ ์ธ๋ฑ์ค ๋ฐํ
}
}
// ๊ฒฐ๊ณผ ๋ฐํ
return newIndex;
}
}
์.... ์ด ๋ฐฉ์์ ์๋ฌด๋ฆฌ ํด๋ ์๋๋ ๊ฒ ๊ฐ๋ค.
์๋ํ๋ฉด ์ฐ์ ์์์ ๊ฐ์ ์ซ์๊ฐ ๋๋ฌด ๋ง์์ ๋ฐํ๋ฐ์ ๊ฐ์ ํน์ ํด ์ฃผ๊ธฐ ์ด๋ ค์ด ๊ฒ ์ฌ์ค์ด๋ค.
priorities ๋ฐฐ์ด์ ๋์ผํ ๊ฐ์ด ์ฌ๋ฌ ๋ฒ ๋ํ๋๋ ๋ฌธ์ ๋๋ฌธ์ mergedArray์์ ์ฌ๋ฐ๋ฅธ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ์ง ๋ชปํ๊ณ ์๋ค. ๋ด๊ฐ ์จ ๋ด๋ ค ๊ฐ๋ฉด์ ์ด ์ฝ๋๋ ๋ต์ด ์๋ค๊ณ ์๊ฐํ ์๊ฐ์ด ์๋๋ฐ, ๊ฑฐ์ ๋์ ์ฏค originalValue๋ฅผ ๋ฐํํ๋ ์ฝ๋๋ฅผ ์ ์ ๋์ด๋ค. ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ฐพ์ ์ฌ ์ ๋ฐ์ ์๋ค๋ ๊ฑธ ๊นจ๋ณ์์ ๋ ์์ ์ฝ๋๋ ํฌ๊ธฐํด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค. ๊ทธ๋์ ๋ค์ ์์ ์ผ๋ก ๋์๊ฐ์ ์๊ฐ์ ํด ๋ณด์๋ค.
์ฌ์ ํ ๋ฐฐ์ด๋ก ํธ๋ ๋ฐฉ๋ฒ๊ณผ ํ๋ฅผ ์ฌ์ฉํด์ ํธ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
3. ๋ฌธ์ ํ์ด
3-1. ํ ์ ์ฐ๊ณ ๋ฐฐ์ด๋ก ํ๊ธฐ
cnt์ ์ธ : location์ด ๋ช ๋ฒ์งธ๋ก ์ฒ๋ฆฌ๋์๋์ง ๋ด์์ค ๋ณ์
์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ๊ฒ์ด priorities ๋ฐฐ์ด์ ๋งจ ์์ ์๋ ์์(priorities[0])์ธ์ง ํ์ธํ๋ค.
priorities[0] ์ฐ์ ์์๊ฐ max๊ฐ ์๋ ๋
๋งจ ์์ ์ฐ์ ์์ max๊ฐ์ด ์ฌ ๋๊น์ง priorities[0] ์ temp ๋ณ์์ ๋ด์ ์ฃผ๊ณ , priorities[0]์ ๋งจ ๋ค๋ก ๋ณด๋ด์ค๋ค. ๊ทธ๋ฆฌ๊ณ ๋๋จธ์ง ๊ฐ์ ํ ์นธ ์ฉ ์์ผ๋ก ๋น๊ฒจ ์ค๋ค. ์ด ๋, ์์๊ฐ ์ด๋ํด ์ค๋๋ง๋ค location๋ ํ๋์ฉ ๊ฐ์ํด์ค๋ค.
priorities[0] ์ฐ์ ์์๊ฐ max๊ฐ ๋ง์ ๋
- cnt++ ์ฆ๊ฐ: ํ๋ก์ธ์ค๋ฅผ ํ๋ ์ฒ๋ฆฌํ ๋๋ง๋ค cnt๋ฅผ ์ฆ๊ฐ์ํจ๋ค. ์ด ๋ณ์๋ ํ์ฌ๊น์ง ๋ช ๊ฐ์ ํ๋ก์ธ์ค๋ฅผ ์ฒ๋ฆฌํ๋์ง ๋ฐํํ๋ค.
- if (location == 0) ์กฐ๊ฑด: ๋ง์ฝ location์ด 0์ด๋ฉด, ์ง๊ธ ์ฒ๋ฆฌํ๋ ค๊ณ ํ๋ ํ๋ก์ธ์ค๊ฐ ๋ด๊ฐ ์ฐพ๋ ํ๋ก์ธ์ค์ด๋ค. ์ด๋ cnt๋ฅผ ๋ฐํํ๋ฉด ์ด ๋ฌธ์๊ฐ ๋ช ๋ฒ์งธ๋ก ์ฒ๋ฆฌ๋์๋์ง ์ ์ ์๋ค.
๋ง์ฝ priorities = [2, 1, 3, 2]์ด๊ณ location = 2๋ผ๋ฉด, location์ด ๊ฐ๋ฆฌํค๋ ํ๋ก์ธ์ค๋ 3์ด๋ค. 3๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ ํ๋ก์ธ์ค๊ฐ ์์ผ๋ฏ๋ก 3์ ์ฒซ๋ฒ์งธ๋ก ์ฒ๋ฆฌํ๋ค. ๊ทธ๋์ cnt๋ 1์ด ๋๋ค. location == 0 ์ฒดํฌํ๋ ์ด์ ๋ ๋ง์ฝ ์ฒ๋ฆฌํ ํ๋ก์ธ์ค๊ฐ ๋ด๊ฐ ์ถ์ ํ๋ ํ๋ก์ธ์ค(์ธ๋ฑ์ค 2)๋ผ๋ฉด, ์ด๋ cnt๋ฅผ ๋ฐํํด์ 3์ด 1๋ฒ์งธ๋ก ์ถ๋ ฅ๋์๋ค๊ณ ์๋ ค ์ฃผ๊ธฐ ์ํด์์ด๋ค.
import java.util.Arrays;
class Solution {
public int solution(int[] priorities, int location) {
int cnt = 0; // ํ๋ก์ธ์ค๊ฐ ์ฒ๋ฆฌ๋ ์์
while (true) {
// ๊ฐ์ฅ ์์ ์๋ ํ๋ก์ธ์ค๊ฐ ๊ฐ์ฅ ๋์ ์ฐ์ ์์์ธ์ง ํ์ธ
int first = priorities[0];
// ์ฐ์ ์์๊ฐ ๋ ๋์ ๊ฒ์ด ์๋๊ฐ? ๋ถ๋ฆฌ์ธ ํ์
์ ์ธํ๊ณ
// ์ด๊ธฐ๊ฐ false๋ก ์ธํ
boolean higherPriorityExist = false;
// loop ๋๋ฉด์ prioiritis[i] ๊ฐ ์ฒซ๋ฒ์งธ ์์๋ณด๋ค ํฐ ์ง ํ์ธ
// ๋ง์ฝ์ ํ์ฌ ์์ priorities[0]๋ณด๋ค ํฌ๋ฉด
// higherPriorityExist๋ true; ์ด๊ณ break;
for (int i = 1; i < priorities.length; i++) {
if (priorities[i] > first) {
higherPriorityExist = true;
break;
}
}
if (higherPriorityExist) {
// ์ฐ์ ์์๊ฐ ๋ ๋์ ํ๋ก์ธ์ค๊ฐ ์์ผ๋ฉด ๋งจ ๋ค๋ก ์ด๋
// ์ฒซ ๋ฒ์งธ ์์๋ฅผ temp์ ๋ด์ ์ค๋ค.
int temp = priorities[0];
// ๋ฐฐ์ด ์์๋ค์ ํ ์นธ์ฉ ์์ผ๋ก ์ด๋
for (int i = 1; i < priorities.length; i++) {
priorities[i - 1] = priorities[i];
}
// ๋ฐฐ์ด ๋์ temp์ ๋ด์ ๋์๋ ๊ฐ ๋ฃ๊ธฐ
priorities[priorities.length - 1] = temp;
if (location == 0) { // ๋งจ ์์์ ์ด๋ํ์ผ๋ฉด location๋ ๋งจ ๋ค๋ก ์ด๋
location = priorities.length - 1;
} else { // ๋งจ ์์์ ํ๋์ฉ ์ด๋์ํจ ํ ์์น๋ฅผ ํ๋์ฉ ๊ฐ์
location--;
}
} else {
// higherPriorityExist๊ฐ false์ผ ๋ ์คํ
// ์ฆ, ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๊ฐ ๊ฐ์ฅ ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ๊ฒฝ์ฐ
// ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ํ๋ก์ธ์ค๊ฐ ๋งจ ์์ ์์ผ๋ฉด ํ๋ก์ธ์ค ์ฒ๋ฆฌ
//๋งจ ์์ ์๋ ํ๋ก์ธ์ค๊ฐ ์ฒ๋ฆฌ๋์์ผ๋ฏ๋ก cnt๋ฅผ ์ฆ๊ฐ์์ผ
// ์ฒ๋ฆฌ๋ ํ๋ก์ธ์ค์ ์์๋ฅผ ๊ธฐ๋ก
cnt++;
if (location == 0) { // ์ฐพ๋ ํ๋ก์ธ์ค๊ฐ ๋งจ ์์ ์๋ ๊ฒฝ์ฐ
return cnt; // ์นด์ดํธ ๋ฐํ
}
// ๋งจ ์์ ํ๋ก์ธ์ค๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ์์ผ๋ก ํ ์นธ์ฉ ์ด๋
for (int i = 1; i < priorities.length; i++) {
priorities[i - 1] = priorities[i];
}
// ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ฅผ 0์ผ๋ก ์ค์ ํ์ฌ ์ฒ๋ฆฌ๋ ํ๋ก์ธ์ค๋ฅผ ์ ๊ฑฐ๋ ๊ฒ์ผ๋ก ํ์
priorities[priorities.length - 1] = 0;
// location๋ 1์ฉ ๊ฐ์
location--;
}
}
}
}
location์ ์ฐ๋ฆฌ๊ฐ ์ถ์ ํ๋ ํ๋ก์ธ์ค์ ์์น๋ฅผ ๊ฐ๋ฆฌํค๊ธด๋ค. location--์ ๋ฐฐ์ด์ด ์์ผ๋ก ์ด๋ํ๊ธฐ ๋๋ฌธ์ location๋ ํ ์นธ ์์ผ๋ก ์ค์ด๋ค๋๋ก ์กฐ์ ํด ์ฃผ๋ ๊ฒ์ด๊ณ , ๋ง์ฝ location์ด 0์ด ์๋์๋ค๋ฉด, ๊ณ์ ๊ฐ์์์ผ locaiton์ด 0์ด ๋ ๋ ๊น์ง ๋ฐ๋ณตํ๋ค. ๊ทธ ๋๋ง๋ค cnt๊ฐ 1์ฉ ์ฆ๊ฐ ํ๋ฉด์ location์ด ๊ฐ๋ฆฌํค๋ ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์ฒ๋ฆฌ๋๋ ์ง ๊ธฐ๋กํ๋ค.
3-2. ํ๋ก ํ๊ธฐ
ํ์ ์ฐ์ ์์ ์์๋ค์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ถ๊ฐํ๋ค๋ค.
ํ๊ฐ ๋น ๋ ๊น์ง ๋ฐฐ์ด์ ๋๋ฉด์ queue.peek()๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๋๋ค.
ํ์ฌ ์์
์ด location๊ณผ ๊ฐ์ผ๋ฉด cnt ๋ฐํ
import java.util.*;
class Solution {
public int solution(int[] priorities, int location) {
// ๋ด๋ฆผ์ฐจ์ ํ ์ ์ธ
PriorityQueue<Integer> queue = new PriorityQueue<>(Collections.reverseOrder());
int cnt = 0;
// ํ์ ์ฐ์ ์์๋ฅผ ์ฝ์
for (int i : priorities) {
queue.offer(i);
}
// ์ฐ์ ์์ ํ์ ๋ฐฐ์ด์ ์ํํ๋ฉฐ ์ฒ๋ฆฌ
while (!queue.isEmpty()) {
for (int i = 0; i < priorities.length; i++) {
// ํ์ ๊ฐ์ฅ ๋์ ์ฐ์ ์์์ ๋ฐฐ์ด์ ํ์ฌ ๊ฐ์ ๋น๊ต
if (queue.peek() == priorities[i]) {
queue.poll(); // ์ฐ์ ์์ ํ์์ ์ ๊ฑฐ
cnt++; // ํ๋ก์ธ์ค ์์ ์ฆ๊ฐ
// ์ฐพ๊ณ ์๋ ํ๋ก์ธ์ค๊ฐ ํ์ฌ ํ๋ก์ธ์ค์ด๋ฉด cnt ๋ฐํ
if (location == i) {
return cnt;
}
}
}
}
return cnt;
}
}
Queue์ ๋ฐฐ์ด์์๋ฅผ ์ถ๊ฐํ ๋ queue.offer()์ ํด ์ค ์ด์ ๋ queue.add()๋ฉ์๋๋ณด๋ค ์์ ์ฑ ์ธก๋ฉด์์ ์ฐ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. add()๋ ์ฝ์
์ด ์คํจํ ๊ฒฝ์ฐ ์์ธ๋ฅผ ๋์ง๋ ๋ฐ๋ฉด, offer()๋ ์คํจํ ๊ฒฝ์ฐ false๋ฅผ ๋ฐํํ์ฌ ์์ธ๋ฅผ ์ฒ๋ฆฌํ์ง ์๊ณ ๋ ์์ ํ๊ฒ ํ์ ์์๋ฅผ ์ถ๊ฐ ์ ์๋ค. ํนํ ํ์ ํฌ๊ธฐ๊ฐ ์ ํ์ ์ผ ๋ offer()๋ฅผ ์ฐ๋ ๊ฒ์ด ์ข๋ค.
4. ํ์์ ์ฒ๋ฆฌ๋๋ ๋ก์ง
์์ 2์ ์์ ๋ฐฐ์ด [1, 1, 9, 1, 1, 1]์ ํ์ ์ง์ด ๋ฃ์ ๋ชจ์ต์ ๊ตฌ๊ธ ์ฌ๋ผ์ด๋๋ก ๊ทธ๋ ค ๋ณด์๋ค. original ๋ฐฐ์ด priorities์ ์ธ๋ฑ์ค๋ ํจ๊ป ํ์ํด ์ฃผ์๋ค. Prioirity Queue๋ฅผ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ฉด, ๊ฐ์ ์ซ์๋ผ๋ฆฌ๋ ์ด๋ป๊ฒ ๋ ๊น? ๋ด๋ฆผ์ฐจ์์ ์ ์ง๋๋ ๊ฐ์ ๊ฐ์ ๋ํด์๋ ์ฝ์
๋ ์์๊ฐ ์ ์ง๋๋ค. ํ๋ FIFO ํน์ฑ์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ๋ฐฐ์ด priorities = [1, 1, 9, 1, 1, 1]
- location = 5 (๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค)
- cnt = 0
์ฐ์ ์์ ํ๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ queue = [9, 1, 1, 1, 1, 1]
ํ์์ ๊ฐ์ ๊บผ๋ด๋ฉด์ ์นด์ดํธ๋ฅผ ์ฆ๊ฐ์ํค๊ณ , ๊ฐ ๊ฐ์ ์ฒ๋ฆฌํ ํ location์ด ํ์ฌ์ ๋ฐฐ์ด ์ธ๋ฑ์ค์ ๊ฐ์ผ๋ฉด ์นด์ดํธ๋ฅผ ๋ฐํ
Priorities | p[0] | p[1] | p[2] | p[3] | p[4] | p[5] |
1 | 1 | 9 | 1 | 1 | 1 | |
queue ์ฒ๋ฆฌ ๋ก์ง | ||||||
i | 2 | 3 | 4 | 5 | ||
queue.peek() | 9 | 9 | 9 | 1 | 1 | 1 |
priorities[i] | 1 | 1 | 9 | 1 | 1 | 1 |
location | 5 | 5 | 5 | 5 | 5 | 5 |
cnt | 0 | 0 | 1 | 2 | 3 | 4 |
- ์ฒซ ๋ฒ์งธ ํ์ฐจ (queue.peek() == priorities[2]):
- cnt = 1 (์นด์ดํธ 1 ์ฆ๊ฐ)
- location์ ์ฌ์ ํ 5, i๋ 2์ด๋ฏ๋ก ๋ถ์ผ์น
- ๋ ๋ฒ์งธ ํ์ฐจ (queue.peek() == priorities[3]):
- cnt = 2
- location์ ์ฌ์ ํ 5์ด๊ณ , i๋ 3์ด๋ฏ๋ก ๋ถ์ผ์น
- ์ธ ๋ฒ์งธ ํ์ฐจ (queue.peek() == priorities[4]):
- cnt = 3
- location์ ์ฌ์ ํ 5์ด๊ณ , i๋ 4์ด๋ฏ๋ก ๋ถ์ผ์น
- ๋ค ๋ฒ์งธ ํ์ฐจ (queue.peek() == priorities[5\):
- cnt = 4
- location์ 5์ด๊ณ , i๋ 5์ด๋ฏ๋ก location๊ณผ i๊ฐ ์ผ์น
- ์ด๋ cnt๋ฅผ ๋ฐํ
5. ๊ฐ์ ์ ํ ๋ฌธ์ (์คํ/ํ)