22-Seol-Munhyeok

[Seol-Munhyeok]

🔗 문제 링크

두 큐 합 같게 만들기
https://school.programmers.co.kr/learn/courses/30/lessons/118667

✔️ 소요된 시간

30분

✨ 수도 코드

그리디 풀이

입력의 크기가 300,000이므로 모든 pop() 연산 하는 방법을 다 고려하는 것은 불가능합니다.
몇 가지 예시를 살펴보다가 결국 pop() 연산은 두 큐 중 합이 더 큰 큐에서 해야한다는 점을 떠올랐습니다.
그 후 살짝 논리적 비약이 있지만 그냥 매번 합이 더 큰 큐에서 pop()을 반복하고, 그 때 큐의 합이 같아지는 순간이 최적인 거 같았습니다.
이 논리를 가지고 문제에 나온 예시를 대입해보니까 맞는 거 같아서 그렇게 풀어봤습니다.

한 가지 고려할 점은 연산을 몇 번해야 불가능하다는 것을 판단할 수 있을까였습니다.
큐의 길이를 n이라 할 때, pop() 연산을 4n번 하면 어느 한 큐는 pop을 2n번 이상했다는 거고 그 순간 원래의 상태를 지나쳤을테니 pop을 4n번 한 후에도 합이 같아지지 않았다면 불가능이라고 판단할 수 있습니다.

이에 대한 증명은 카카오 공식 해설에서 발췌했습니다.

---

문제에서 요구하는 것은 queue1과 queue2의 원소 합을 같게 만드는 것입니다. 처음 주어진 queue1의 합을 L, queue2의 합을 R이라고 했을 때, L과 R을 같게 만들기 위해서는 다음과 같은 탐욕법을 사용하여 해결할 수 있습니다.

• L > R이라면, queue1의 원소를 queue2로 넘겨줍니다.
• L < R이라면, queue2의 원소를 queue1로 넘겨줍니다.

위 방법이 왜 유효한지 간단하게 증명하면 다음과 같습니다.

앞에서 설명한 방식과 반대로 L > R인 상황에서 먼저 L을 증가시키고 R을 감소시키는 방법이 최적인 경우가 있다고 가정하겠습니다. 이 경우 L = R을 만들기 위해서는 언젠가 L을 감소시키고 R을 증가시켜야 하고, 결국 queue1의 원소를 queue2로 넘겨주는 동작은 반드시 필요합니다. queue2의 원소를 queue1으로 넘겨준 이후에 queue1의 원소를 queue2로 넘겨주든, 이 순서를 반대로 하든 결과는 동일하기 때문에, L > R인 상황에서 L을 감소시키는 방법은 항상 최적이 될 수 있습니다.

그리디 코드

from collections import deque

def solution(queue1, queue2):
    q1, q2 = deque(queue1), deque(queue2)
    sum1, sum2 = sum(q1), sum(q2)

    if (sum1 + sum2) % 2 == 1:
        return -1
    
    n = len(q1)
    for i in range(4*n+1):
        if sum1 > sum2:
            value = q1.popleft()
            q2.append(value)
            sum1 -= value
            sum2 += value
        elif sum1 < sum2:
            value = q2.popleft()
            q1.append(value)
            sum2 -= value
            sum1 += value
        else:
            return i
        
    return -1

• 직접 큐(Queue) 자료구조를 이용하지 않고 단순히 배열을 큐로 사용하면 0번 원소를 지우는 과정에서 시간 초과가 발생할 수 있습니다.
• 두 큐의 원소의 합이 홀수면 절대로 두 큐의 합을 같게 만들 수 없으므로 미리 전처리해서 최적화할 수 있습니다.
• pop() 연산 후, 두 큐의 합을 갱신할 때, for문 안에 sum1, sum2 = sum(q1), sum(q2) 로 매번 계산하면 시간초과가 발생합니다. 위 코드와 같은 방식으로 합계를 갱신해야 통과합니다.

투 포인터 풀이

이 문제는 투 포인터로도 풀 수 있습니다. 뭔가 풀이가 한 번에 이해하기 쉽지는 않습니다.

먼저 queue1을 왼쪽, queue2를 오른쪽에 이어 붙이고 하나의 배열처럼 본다고 생각해 봅시다. 이 경우 각 큐에 pop 또는 insert 연산을 하는 것은 배열의 경계를 이동시키거나 맨 앞의 원소를 맨 뒤에 이동시키는 연산을 하는 것이라고 볼 수 있으므로, 각 큐는 이렇게 정의한 배열에서 연속된 구간의 원소로만 이루어진다고 생각할 수 있습니다.

(그림 출처 : https://blog.encrypted.gg/1076)

즉 두 큐를 이어 붙이고 맨 끝 원소는 맨 앞 원소랑 연속한 거로 생각하고, 모든 시작점에 대해 원소의 합이 전체의 절반일 때마다 연산 횟수를 계산해서 최솟값을 갱신하면 됩니다.

제가 투 포인터 풀이에 대해서 여러 코드를 살펴봤는데, 전체적인 느낌은 그리디 코드와 결이 같다고 느낍니다. 그리디 코드는 실제로 queue에 pop과 insert를 하면서 살펴보는 거고, 투 포인터 풀이는 두 큐를 붙이고 포인터를 이동하면서 pop과 insert를 했다고치고 살펴보는 거 같았습니다.

혹시 다른 분들도 그리디말고 다른 풀이가 있다면 공유 부탁드립니다!

📚 새롭게 알게된 내용

두 큐에서 따로 연산을 수행할 때, 두 큐를 붙여서 본다는 관점을 얻어갈 수 있는 문제라고 생각합니다!

[hyeokbini]

문제를 푸는 로직 자체는 스무스하게 작성했는데, 문혁님이 짚어주신 부분인 반복문을 끝낼 조건을 어떻게 처리해야 할지에 대한 갈피를 한동안 못 잡았었네요.

고민하다가 두 큐에서 원소가 빠지고, 들어가는 과정이 반복되다 보면 결국 원래 상태로 돌아올 수 있고, 총 횟수는

Q1(q1), Q2(q2) -> Q1(q1,q2), Q2() -> N
Q1(q1,q2), Q2() -> Q1(q2), Q2(q1) -> N
Q1(q2), Q2(q1) -> Q1(), Q2(q1,q2) -> N
Q1(), Q2(q1,q2) -> Q1(q1), Q2(q2) -> N

총 4N번만큼의 연산동안 합이 같은 경우를 찾지 못하면 해답이 없는 것으로 간주하고 -1을 return하도록 했습니다.

전체적인 로직은 문혁님 코드와 비슷한 것 같습니다. 미리 두 벡터 전체 합을 구해준 다음 벡터를 덱 자료구조에 넣고 총합이 큰 쪽에서 작은 쪽으로 원소를 pop(), push()해주며 슬라이딩 윈도우 느낌으로 합을 갱신해서 가장 먼저 합이 같게 나온 경우의 카운트를 return해 주었습니다.

실제로 2번 테스트 케이스로 적어보면서 시뮬레이션 해보니 맞는 것 같길래 엄밀한 증명 없이 바로 구현했습니다.

직관적으로 당연히 합이 더 많은 쪽에서 작은 쪽으로 원소를 옮겨 주는 로직을 써야 한다고는 생각했지만, 엄밀한 증명을 할 생각은 못 했는데 풀이를 가져와 주신 덕에 엄밀한 증명을 이해하고 가는 것 같습니다.

이번 문제에선 명시적으로 힌트를 주고 있지만, 입력 배열 길이와 원소 크기를 고려한다면 힌트가 없어도 long long 사용을 고려해봐야 한다는 것도 리마인드하고 갑니다.

제출 코드입니다. 고생하셨어요! 😄

두 큐 합 같게 만들기

#include <bits/stdc++.h>

using namespace std;

int solution(vector<int> queue1, vector<int> queue2) {
    int answer = -1;
    deque<int> Q1(queue1.begin(), queue1.end());
    deque<int> Q2(queue2.begin(), queue2.end());
    long long sum1 = 0;
    long long sum2 = 0;
    int limit = queue1.size();
    int count = 0;
    for(int i = 0; i < limit; i++)
    {
        sum1 += queue1[i];
        sum2 += queue2[i];
    }
    while(count <= limit * 4)
    {
        if(sum1 > sum2)
        {
            Q2.push_back(Q1.front());
            sum1 -= Q1.front();
            sum2 += Q1.front();
            Q1.pop_front();
        }
        else if(sum1 < sum2)
        {
            Q1.push_back(Q2.front());
            sum1 += Q2.front();
            sum2 -= Q2.front();
            Q2.pop_front();
        }
        else
        {
            answer = count;
            break;
        }
        count++;
    }
    
    return answer;
}

[mj010504]

저도 이전에 풀었던 문제인데 원소크기를 고려하여 long 타입을 사용해야 한다는 것을 리마인드 했고, 반복문을 끝내는 조건을 파악해야 한다는 것이 재미있는 그리디 문제네요. 수고하셨습니다!

두 큐 합 같게 만들기

#include<bits/stdc++.h>

using namespace std;

int solution(vector<int> a, vector<int> b) {
    int res = 0;
    long long sum1 = 0;
    long long sum2 = 0;
    
    queue<int> q1;
    queue<int> q2;
    for(int i = 0; i < a.size(); i++) {
        sum1 += a[i];
        q1.push(a[i]);
    }
    
     for(int i = 0; i < b.size(); i++) {
        sum2 += b[i];
        q2.push(b[i]);
    }
    
    if((sum1 + sum2) % 2 != 0) return -1;
    
    int n = a.size() * 4;
    
    while(n--) {
        if(sum1 < sum2) {
            int tmp = q2.front();
            q2.pop();
            q1.push(tmp);
            
            sum1 += tmp;
            sum2 -= tmp;
            res++;
        }
        else if(sum1 > sum2) {
             int tmp = q1.front();
            q1.pop();
            q2.push(tmp);
            
            sum1 -= tmp;
            sum2 += tmp;
            res++;
        }
        else {
            return res;
        }
    }
    
    return -1;
}

[flydongwoo]

두 큐의 합을 같게 만들기 위해 원형 배열로 합쳐 두 포인터를 움직이며 한쪽 합을 목표값에 맞추는 과정을 시뮬레이션하는 코드로 짜보았습니다

두 큐 합 같게 만들기

#include <iostream>
#include <vector>
using namespace std;

long long sum_vec(const vector<long long>& v, size_t start, size_t end) {
    long long s = 0;
    for (size_t i = start; i < end; i++) {
        s += v[i];
    }
    return s;
}

int solution(vector<int> queue1, vector<int> queue2) {
    size_t n = queue1.size();
    vector<long long> A(2 * n);
    for (size_t i = 0; i < n; i++) {
        A[i] = queue1[i];
        A[n + i] = queue2[i];
    }

    long long sum1 = 0;
    long long sum2 = 0;

    for (int x : queue1) {
        sum1 += x;
    }
    for (int x : queue2) {
        sum2 += x;
    }

    long long total = sum1 + sum2;
    if (total % 2 != 0) {
        return -1;
    }
    long long target = total / 2;

    size_t l = 0;
    size_t r = n;
    long long curr1 = sum1;
    int cnt = 0;
    int max_ops = 4 * n;

    while (cnt <= max_ops) {
        if (curr1 == target) {
            return cnt;
        }
        if (curr1 > target) {
            curr1 -= A[l];
            l = (l + 1) % (2 * n);
        }
        else {
            curr1 += A[r];
            r = (r + 1) % (2 * n);
        }
        cnt++;
    }

    return -1;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    vector<int> q1 = {3, 2, 7, 2};
    vector<int> q2 = {4, 6, 5, 1};

    int ans = solution(q1, q2);
    cout << ans << "\n";

    return 0;
}

수고 많으셨습니다!