1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
KEY WORD
: GREEDY
- ๋ฌธ์ ์ค๋ช ๊ทธ๋๋ก Queue ๋ ๊ฐ๋ฅผ ๋ง๋ ๋ค.
- ์ดํฉ์ด ํฐ ์ชฝ์ queue.peek()์ poll ํด์ ๋ค๋ฅธ ์ชฝ ํ์ ์ถ๊ฐํ๋ค.
- 2๋ฒ ์ข ๋ฃ ํ ๋ ํ์ ์ดํฉ์ด ๊ฐ์์ง ๊ฒ์ฌํ๋ค.
- ๋ง์ฝ ๊ฐ์ผ๋ฉด, 2๋ฒ์ ํํ ํ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ
๋ ํ์ ์ด ๊ธธ์ด + 1
๋งํผ ํด๋ ๋ ํ์ ํฉ์ด ๊ฐ์ง ์์ผ๋ฉด -1์ ์ถ๋ ฅํ๊ณ ์ข ๋ฃ ํ๋ค.
๋ ํ์ ์ด ๊ธธ์ด + 1 ๋งํผ ๋ฐ๋ณตํด์ผ ํ๋ ์ด์ ๋ ๋ค์์ ์ค๋ช .
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
public int solution(int[] queue1, int[] queue2) {
ArrayDeque<Integer> a = new ArrayDeque<>();
ArrayDeque<Integer> b = new ArrayDeque<>();
// sum == ๊ฐ ํ์ ํฉ, cnt == ์์
ํ์
long sumA = 0;
long sumB = 0;
int cnt = 0;
for(int i = 0; i < queue1.length; i++){
a.add(queue1[i]);
b.add(queue2[i]);
sumA += queue1[i];
sumB += queue2[i];
}
if((sumA+sumB)%2 == 1) return -1;
// ๊ทธ ๋ ๊ทธ ๋ ๋งค๋ฒ sum์ ๊ตฌํ์ง ๋ง๊ณ , ํ๋ ๊ตฌํด๋๊ณ +,-๋ก ์กฐ์ ํ๋ค.
while(sumA != sumB){
// ๊ธฐ์ ์กฐ๊ฑด
if(cnt > (queue1.length + queue2.length)+1) {
cnt = -1;
break;
}
if(sumA > sumB){
int now = a.poll();
sumA -= now;
sumB += now;
b.add(now);
}
else if(sumB > sumA){
int now = b.poll();
sumB -= now;
sumA += now;
a.add(now);
}
cnt++;
}
return cnt;
}
}
4. ์ฑ์ฅ ํ๊ธฐ
(1) ํด๋น ๋ฌธ์ ์์ ์์์ ์ต๋ ํฌ๊ธฐ๋ 10^9์ด์๋ค. ๋ฐ๋ผ์ ์ดํฉ์ ๊ตฌํ ์, intํ์ ์ต๋๊ฐ์ธ 21์ต์ ๋์ ์ ์๋ค.
sum์ ์๋ฃํ์ int๊ฐ ์๋๋ผ Long์ผ๋ก ํด์ผํ๋ค.
-> ํด๋น ๋ถ๋ถ์ ์์ฃผ ๊ฐ๊ณผํด์, ๋ง๋ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ๋ ํด๋ฉ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ์๋ฃํ์ด ๋ณ์์ ๊ฐ์ ๊ฐ๋นํ ์ ์๋์ง๋ฅผ ํญ์ ์ฒดํฌํ์.
(2) ๋ฐ๋ณต๋ฌธ์ด queue์ ๊ธธ์ด์ ํฉ + 1
๋งํผ ๋ฐ๋ณต๋์ด์ผ ํ๋ ์ด์
Input์ ๋ค์๊ณผ ๊ฐ์ด ๋ฃ์ด๋ณด์.
queue1 | queue2 | result |
---|---|---|
[3,3,3,3] | [3,3,27,3] | 9 |
ํด๋น ๊ฐ์ด ์๋ก 27๋ก ์ผ์นํ๊ธฐ ์ํด์๋ 9๋ฒ์ ์์ง์์ด ํ์ํ๋ค. ๋ฐ๋ผ์ queue์ ๊ธธ์ด์ ์ดํฉ ๋ณด๋ค ์ข ๋ ๋๋ํ ๊ฐ์ ธ๊ฐ์ผ ํ๋ค. ์ด๊ฒ์ ๋ฐ๋ก ์ ์ ํ์
ํ ์ ์๋ ๋ฐฉ๋ฒ์ด ์๋์ง๋ ์์ง ์ ๋ชจ๋ฅด๊ฒ ๋ค.
๋ค์์ ์ฝ๋ฉ ํ
์คํธ์์๋ ์ผ๋ถ ํ๋ฆด ๊ฒฝ์ฐ, ์ด๋ฌํ ๋ฐ๋ก๊ฐ ์์ ๊ฒฝ์ฐ๋ฅผ ๋๋นํด ๋ฐ๋ณต๋ฌธ์ ๊ธธ์ด๋ฅผ ์๊ฐ ์ด๊ณผ๊ฐ ์๋๋ ์ ์์ ๋๋ํ ๊ฐ์ ธ๊ฐ๋ ๋ฐฉ๋ฒ์ ๊ณ ๋ คํ์.