https://school.programmers.co.kr/learn/courses/30/lessons/118667
๋ฌธ์ ์ค๋ช
๊ธธ์ด๊ฐ ๊ฐ์ ๋ ๊ฐ์ ํ๊ฐ ์ฃผ์ด์ง๋๋ค. ํ๋์ ํ๋ฅผ ๊ณจ๋ผ ์์๋ฅผ ์ถ์ถ(pop)ํ๊ณ , ์ถ์ถ๋ ์์๋ฅผ ๋ค๋ฅธ ํ์ ์ง์ด๋ฃ๋(insert) ์์ ์ ํตํด ๊ฐ ํ์ ์์ ํฉ์ด ๊ฐ๋๋ก ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค. ์ด๋ ํ์ํ ์์ ์ ์ต์ ํ์๋ฅผ ๊ตฌํ๊ณ ์ ํฉ๋๋ค. ํ ๋ฒ์ pop๊ณผ ํ ๋ฒ์ insert๋ฅผ ํฉ์ณ์ ์์ ์ 1ํ ์ํํ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
ํ๋ ๋จผ์ ์ง์ด๋ฃ์ ์์๊ฐ ๋จผ์ ๋์ค๋ ๊ตฌ์กฐ์ ๋๋ค. ์ด ๋ฌธ์ ์์๋ ํ๋ฅผ ๋ฐฐ์ด๋ก ํํํ๋ฉฐ, ์์๊ฐ ๋ฐฐ์ด ์์ชฝ์ ์์์๋ก ๋จผ์ ์ง์ด๋ฃ์ ์์์์ ์๋ฏธํฉ๋๋ค. ์ฆ, pop์ ํ๋ฉด ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๊ฐ ์ถ์ถ๋๋ฉฐ, insert๋ฅผ ํ๋ฉด ๋ฐฐ์ด์ ๋์ ์์๊ฐ ์ถ๊ฐ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ํ [1, 2, 3, 4]๊ฐ ์ฃผ์ด์ก์ ๋, pop์ ํ๋ฉด ๋งจ ์์ ์๋ ์์ 1์ด ์ถ์ถ๋์ด [2, 3, 4]๊ฐ ๋๋ฉฐ, ์ด์ด์ 5๋ฅผ insertํ๋ฉด [2, 3, 4, 5]๊ฐ ๋ฉ๋๋ค.
๋ค์์ ๋ ํ๋ฅผ ๋ํ๋ด๋ ์์์ ๋๋ค.
queue1 = [3, 2, 7, 2] queue2 = [4, 6, 5, 1]
๋ ํ์ ๋ด๊ธด ๋ชจ๋ ์์์ ํฉ์ 30์ ๋๋ค. ๋ฐ๋ผ์, ๊ฐ ํ์ ํฉ์ 15๋ก ๋ง๋ค์ด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
- queue2์ 4, 6, 5๋ฅผ ์์๋๋ก ์ถ์ถํ์ฌ queue1์ ์ถ๊ฐํ ๋ค, queue1์ 3, 2, 7, 2๋ฅผ ์์๋๋ก ์ถ์ถํ์ฌ queue2์ ์ถ๊ฐํฉ๋๋ค. ๊ทธ ๊ฒฐ๊ณผ queue1์ [4, 6, 5], queue2๋ [1, 3, 2, 7, 2]๊ฐ ๋๋ฉฐ, ๊ฐ ํ์ ์์ ํฉ์ 15๋ก ๊ฐ์ต๋๋ค. ์ด ๋ฐฉ๋ฒ์ ์์ ์ 7๋ฒ ์ํํฉ๋๋ค.
- queue1์์ 3์ ์ถ์ถํ์ฌ queue2์ ์ถ๊ฐํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ queue2์์ 4๋ฅผ ์ถ์ถํ์ฌ queue1์ ์ถ๊ฐํฉ๋๋ค. ๊ทธ ๊ฒฐ๊ณผ queue1์ [2, 7, 2, 4], queue2๋ [6, 5, 1, 3]๊ฐ ๋๋ฉฐ, ๊ฐ ํ์ ์์ ํฉ์ 15๋ก ๊ฐ์ต๋๋ค. ์ด ๋ฐฉ๋ฒ์ ์์ ์ 2๋ฒ๋ง ์ํํ๋ฉฐ, ์ด๋ณด๋ค ์ ์ ํ์๋ก ๋ชฉํ๋ฅผ ๋ฌ์ฑํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ๊ฐ ํ์ ์์ ํฉ์ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์์ ์ ์ต์ ํ์๋ 2์ ๋๋ค.
๊ธธ์ด๊ฐ ๊ฐ์ ๋ ๊ฐ์ ํ๋ฅผ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด queue1, queue2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๊ฐ ํ์ ์์ ํฉ์ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์์ ์ ์ต์ ํ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๋จ, ์ด๋ค ๋ฐฉ๋ฒ์ผ๋ก๋ ๊ฐ ํ์ ์์ ํฉ์ ๊ฐ๊ฒ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ, -1์ return ํด์ฃผ์ธ์.
๋ด ํ์ด
ํ๋ฅผ ๋ง๋ค์ด์ vector์ ๊ฐ์ ํ์ ๋ฃ์ด์ ํ์ด๋ ๋๊ณ ,
๊ทธ๊ฒ๋ ๊ท์ฐฎ์ผ๋ฉด ํฌ์ธํฐ๋ฅผ ๋ง๋ค์ด์ ํฌ์ธํฐ๋ฅผ ํ๋์ฉ ์ด๋์ํค๋ฉด์,
๋ ํ ์ค์ ์ด ํฉ์ด ๋ ํฐ ํ์ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ์ ๋ฌํ๋ ์์ผ๋ก ๊ตฌํํด๋ ๋๋ค.
๋๋ ํฌ์ธํฐ ๋ฐฉ์์ผ๋ก ๊ตฌํํด๋ดค๋ค.
#include <string>
#include <vector>
#include <iostream>
using namespace std;
int solution(vector<int> queue1, vector<int> queue2) {
int answer = 0;
vector<int>::iterator iter1 = queue1.begin(), iter2 = queue2.begin();
long long total = 0, q1_sum = 0, q2_sum = 0;
for(int i = 0; i < queue1.size(); i++)
{
q1_sum += queue1[i];
q2_sum += queue2[i];
}
total = q1_sum + q2_sum;
// ๋ ํ์ ๋ฐ์ดํฐ ์ด ํฉ์ด ํ์๋ฉด ๋ถ๊ฐ๋ฅํ๋ค.
if(total % 2 == 1)
{
answer = -1;
return answer;
}
while(true)
{
if(q1_sum == q2_sum)
break;
// iter ์ค ํ๋๋ผ๋ ์๋ ํ์ ๋์ ๋๋ฌํ์ ๊ฒฝ์ฐ -> ํ์ ์๋ฃ
if(iter1 == queue2.end() || iter2 == queue1.end())
{
answer = -1;
break;
}
if(q1_sum > q2_sum)
{
// q1์์ q2๋ก ๊ฐ ์ ๋ฌ
int data = *iter1;
q1_sum -= data;
q2_sum += data;
++iter1;
// iter1๊ฐ queue1 ๋์ ๋๋ฌํ๋ฉด queue2 ์์์ ์ ๊ฐ๋ฆฌํจ๋ค
if(iter1 == queue1.end())
iter1 = queue2.begin();
}
else
{
// q2์์ q1์ผ๋ก ๊ฐ ์ ๋ฌ
int data = *iter2;
q1_sum += data;
q2_sum -= data;
++iter2;
// iter2๊ฐ queue2 ๋์ ๋๋ฌํ๋ฉด queue1 ์์์ ์ ๊ฐ๋ฆฌํจ๋ค
if(iter2 == queue2.end())
iter2 = queue1.begin();
}
++answer;
}
return answer;
}
'๐ฅ๏ธ Study Note > Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค]level.2 - ๋ง๋ฒ์ ์๋ฆฌ๋ฒ ์ดํฐ(C++) (0) | 2023.07.11 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค]level.2 - ๋ฐฐ๋ฌ(C++) (0) | 2023.07.10 |
[ํ๋ก๊ทธ๋๋จธ์ค]level.2 - N๊ฐ์ ์ต์๊ณต๋ฐฐ์(C++) (0) | 2023.07.03 |
[ํ๋ก๊ทธ๋๋จธ์ค]level.2 - ์ ํ์ ์๊ฐ ์ด๋(C++) (0) | 2023.06.30 |
[ํ๋ก๊ทธ๋๋จธ์ค]level.2 - ๊ณผ์ ์งํํ๊ธฐ(C++) (0) | 2023.06.29 |