14-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[두 용액]

✔️ 소요된 시간

47m

✨ 수도 코드

새로운 유형의 문제가 필요할 것 같아서 가져와봤습니다~
투 포인터 문제인데요, 정렬과 이분 탐색 등에서 사용하는 방식이라고 합니다.

문제를 읽고 요약하면 다음과 같습니다.

서로 합쳐서 가장 0에 가까운 값이 되는 두 용액을 출력하라.

끝입니다!

투 포인터 문제인걸 알고 들어와서 아이디어는 꽤 금방 생각났고 빠르게 구현을 해나갔습니다.

1. 입력받은 용액 정렬
2. 왼쪽, 오른쪽 끝에서 한 칸씩 줄여가며 조건에 맞는 인덱스찾기

1번은 쉽고 2번은 다음과 같은 핵심로직을 통해 구현할 수 있습니다.

if (mix > 0) right--;
else left++;

왜냐하면 정렬이 되어있기 때문이죵

그런데 1번, 2번 과정 중에서 해야하는 행동이 있습니다.
만약 합쳐서 0이되는 두 용액이 존재하지 않을 경우에는 가장 0에 가까운 녀석을 만드는 두 값을 출력해야합니다.

따라서...
과거와 현재의 abs(mix)값을 비교하고 더 작은 값을 생성하는 두 값을 갱신하며 기록해두는 로직이 필요합니다!
그렇게 구현하면 이 문제는 정답입니다~

📚 새롭게 알게된 내용

혹시 코드 보시고 이상한 점 눈치채셨나요?

왜 이렇게 구현했을까요?

if (mix == 0) {
    cout << have[left] << " " << have[right];
    return 0;
}

저는 내부에서 return 하는 성향이 아니라 break해서 외부에서 주로 출력하는데요 왜 이랬을까요?

그건 제가 실수로 while 내부에서 long int mix = have[left] + have[right]; 이렇게... 해버렸기 때문입니다.
(내부 변수로 선언되어 밖에서 사용하는 mix와 내부 mix는 서로 다른 변수가 되어버렸던 것..)

지금 보니까 보이는데 문제 풀이 당시에는 이게 안보여서 10분 정도 고민했네요...

[g0rnn]

투포인터 문제는 처음 풀어본 것 같은데 풀이를 보니 어디선가 한번 본듯한 형태네요! 덕분에 투포인터 문제에 접근할 수 있어 좋았습니다.

물론 저는 투포인터가 뭔지 몰라서 해석에 적힌 이진탐색을 활용했습니다. 확실히 코드가 많이 복잡하네요. 그리고 시간 복잡도가 많이 딸리네요.

code

//
// Created by 김균호 on 2025. 1. 12..
//
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int n;
vector<int> solution;

int bSearch(int target, int exclusive) {
    int s = 0, e = n - 1;

    // 배제해야하는 index가 0이면 solution 배열의 1부터 시작 -> 해당 위치를 선택안하는 것
    // 배제해야하는 index가 0이 아닌 경우 0부터 시작 
    int closest = (exclusive == 0) ? solution[1] : solution[0];

    while (s <= e) {
        int mid = (s + e) / 2;
        int midVal = solution[mid];

        // 근사치 업데이트
        if (exclusive != mid && abs(midVal - target) < abs(closest - target))
            closest = midVal;
        if (midVal == target) return target;
        else if (midVal > target) e = mid - 1;
        else s = mid + 1;
    }
    // 원하는 값을 못찾으면 근사치 반환
    return closest;
}

int main() {
    cin >> n;
    solution = vector<int>(n, 0);
    for (int i = 0; i < n; i++)
        cin >> solution[i];

    sort(solution.begin(), solution.end());

    int diff = INT_MAX;
    int fir = 0, sec = 0;

    for (int i = 0; i < n; i++) {
        int sol = solution[i];
        // 현재 용액의 값과 부호만 다른 값을 원하니 -를 붙임
        int closest = bSearch(-sol, i);
        if (diff > abs(sol + closest)) {
            diff = abs(sol + closest);
            fir = sol;
            sec = closest;
        }
    }
    if (fir < sec) cout << fir << ' ' << sec;
    else cout << sec << ' ' << fir;
    return 0;
}

이 문제가 벌써 작년 꺼였네요.. 고생하셨습니다

[g0rnn]

마지막에 언급한게 여기 부분을 break하지 않은 이유인가요?

제 생각엔 mix가 내부에서 새로 선언되긴 했지만 로직에는 문제가 없어 보입니다.. break를 사용하기 위해선 순서를 바꿔 if(abs(mix)<abs(pMix)) 다음에 if문으로 들어가야할 것 같아요! 방금 해보니까 성공적으로 통과하였습니다 :)

[kangrae-jo]

마지막에 언급한게 여기 부분을 break하지 않은 이유인가요?

네 맞아요

제 생각엔 mix가 내부에서 새로 선언되긴 했지만 로직에는 문제가 없어 보입니다.. break를 사용하기 위해선 순서를 바꿔 if(abs(mix)<abs(pMix)) 다음에 if문으로 들어가야할 것 같아요! 방금 해보니까 성공적으로 통과하였습니다 :)

오 그렇군요 저 코드를 짤때 if문의 순서를 바꾼다거나 하는 것은 생각하지 못했네요 감사합니당👍

[kokeunho]

최근에 교보문고에서 시간 떼우면서 알고리즘 책 읽었는데
앞 쪽에 투포인터 문제가 있더라구요.
그래서 어느정도 감이 잡혀 있는 상태에서 문제를 풀 수 있었습니다.
코드는 거의 비슷합니다.
정렬하고
포인터 두 개를 각각 맨 앞, 맨 뒤에서 시작하여
두 값의 합을 구하며 합의 값이 양수냐 음수냐에 따라 포인터를 다르게 움직이면서 절대값이 0에 가장 가까운 값을 찾습니다.

Java code

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] products = new int[N];

        for (int i = 0; i < N; i++) {
            products[i] = sc.nextInt();
        }

        Arrays.sort(products);
        
        int first = Integer.MAX_VALUE;
        int a = 0;
        int b = N - 1;
        
        int resultA = 0;
        int resultB = 0;
        
        while (a < b) {
            int sum = products[a] + products[b];
            
            if (Math.abs(first) > Math.abs(sum)) {
                first = sum;
                resultA = products[a];
                resultB = products[b];
            }
            
            if (sum < 0) {
                a++;
            } else {
                b--;
            }
        }
        System.out.println(resultA + " " + resultB);
    }
}

책에서 읽은 내용을 익힐 수 있는 문제였습니다. 수고하셨습니다.

[wnsmir]

이 문제에서는 합이 0에 가장 가까운 두 수를 찾는것입니다.

즉 절댓값이 가장 작은값을 찾는것이 핵심입니다. 원래라면 N개의 값이 주어지면, 모든 배열의 쌍을 비교해야하기 때문에 N^2의 시간복잡도가 필요합니다.

만약 투포인터를 사용한다면, 먼저 정렬을 하고 양쪽 끝값을 비교하며 음수 두개를 더한다던지, 값의 차이가 많이나는 두 수를 더한다던지 하는 불필요한 쌍을 제거할 수 있게 됩니다.

음수 양수가 존재할때, 배열의 양끝값을 더했을때 절댓값이 가장 낮을 확률이 높기 떄문입니다.

N = int(input())
values = list(map(int, input().split()))
INF = 987654321

def calculate(N, values):
    values.sort()
    left = 0
    right = N - 1
    smallest = INF
    result = (0, 0)

    while left < right:
        current = values[left] + values[right]

        if abs(current) < abs(smallest):
            smallest = current
            result = (values[left], values[right])

        if current < 0:
            left += 1
            
        elif current > 0:
            right -= 1
            
        else:
            break
        
    return result

result = calculate(N, values)
print(result[0], result[1])

여기서 while문 즉 left < right는 두 포인터가 서로 교차하면 탐색이 종료된다는 뜻입니다.
종료 전까지 두 포인터가 가리키는 두 값의 합을 계산하며 0에 가까울수록 결과를 갱신합니다.

현재값이 음수라면 left포인터를 오른쪽으로 하나 이동해 음수의 값을 낮춰주고, 반대의 상황이라면 양수의 값을 하나 낮추어줍니다.

이렇게 확인하게되면 시간복잡도가 단순히 모든쌍을 비교하는 것과는 다르게 각 포인터의 최대 이동횟수 N번입니다.

정렬에서 NlogN, 탐색에서 N 즉 둘을 더하면 NlogN입니다.
정렬을 하고 찾는데도, 단순히 모든쌍을 구하는 이중 반복문보다 더 적은 시간복잡도로 가능하게됩니다.

• 두 값 또는 구간을 선택해야하는 경우에서 중복탐색시간을 줄여야하는 경우가 특수하지만, 다음에 이런 경우가 나온다면 떠올려서 사용할 수 있을것 같습니다!