43-gjsk132

[gjsk132]

🔗 문제 링크

백준 20366 : 같이 눈사람 만들래?

✔️ 소요된 시간

1시간 30분

✨ 수도 코드

🎯 문제 이해

문제 요약
4개를 선택해서 눈사람 2개를 만든다.
2개의 지름의 합이 눈사람의 키이다.
2개의 눈사람의 키 차이가 최소인 값을 출력하라.

처음에는 4개를 다 골라줘야하나 싶었는데...

그냥 2개는 미리 골라서 target으로 정하고, 나머지 2개를 투포인터로 돌면서 target값과 가까워지도록 하였다.
사용한 눈덩이는 쓰면 안되기 때문에 사용한 눈덩이와 같은 idx로 가면 스킵해준다.

🔍코드 설명

주요 코드

가장 핵심이 되는 투포인터 코드입니다.

2개로 선정한 값을 block1, block2로 정하고, 해당 위치의 눈덩이 지름의 합을 target으로 지정해줍니다.

최소 차이를 target으로 해두고, start와 end로 반복문을 돌려줍니다.

만약 block1과 block2랑 겹친다면 start면 +1, end면 -1을 해줍니다.

이후에는 start와 end로 만든 눈사람의 키를 target과 비교해서 반복문을 돌려주면 됩니다.

끝나고 나면 가장 작은 키 차이를 출력해줍니다.

def two_pointer(block1, block2):
    start, end = 0, n-1

    target = snow[s1] + snow[s2]

    min_gap = target

    while not start == end:
        if start == block1 or start == block2:
            start += 1
            continue
        
        if end == block1 or end == block2:
            end -= 1
            continue
        
        height = snow[start] + snow[end]

        min_gap = min(min_gap, abs(target-height))

        if height > target:
            end -= 1
        else:
            start += 1
    return min_gap

위 투포인터 코드를 이용하여
2중 반복문으로 고정하려는 2개의 눈덩이를 정해주고, 최소값을 answer에 정해줍니다.

시간을 줄이기 위해 answer이 0이 되는 값이 나오면 반복을 중단하고, 결과를 출력합니다.

answer = snow[0] + snow[n-1]

for s1 in range(n-1):

    if not answer:
        break

    for s2 in range(s1+1, n):
        answer = min(answer, two_pointer(s1, s2))

        if not answer:
            break

print(answer)

전체 코드

input = open(0).readline

n = int(input())

snow = sorted(list(map(int,input().split())))

min_gap_height = float("inf")

target = 0

def two_pointer(block1, block2):
    start, end = 0, n-1

    target = snow[s1] + snow[s2]

    min_gap = target

    while not start == end:
        if start == block1 or start == block2:
            start += 1
            continue
        
        if end == block1 or end == block2:
            end -= 1
            continue
        
        height = snow[start] + snow[end]

        min_gap = min(min_gap, abs(target-height))

        if height > target:
            end -= 1
        else:
            start += 1
    return min_gap


answer = snow[0] + snow[n-1]

for s1 in range(n-1):

    if not answer:
        break

    for s2 in range(s1+1, n):
        answer = min(answer, two_pointer(s1, s2))

        if not answer:
            break

print(answer)

📚 새롭게 알게된 내용

최근에 투포인터 문제를 많이 접했는데, 자주 안 풀어봐서 한 번 풀어봅니담
그래도 아직 응용하려고 하니까 약간 어렵네요 후음 🤔

[9kyo-hwang]

저도 처음엔 "뭐지 포인터 4개를 갖고 놀아야 하나?" 이 생각했다가 엘사 눈덩이는 2중 for문으로 naive하게 돌리고 안나 눈덩이 2개에 대해서 투포인터를 굴리는 방식으로 했습니다.

그런데 너무 오래 걸리는 군요. 짐작은 했지만...

그래서 가능한 눈사람 조합을 미리 배열에 저장해둔 뒤, 거기서 투포인터를 돌리는 식으로 고쳐보니까 시간이 확 빨라지네요 :)

변경된 코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct FSnowman
{
    int Height;
    int FirstSnowball;
    int SecondSnowball;
    
    FSnowman(int InHeight, int InFirstSnowball, int InSecondSnowball)
    : Height(InHeight)
    , FirstSnowball(InFirstSnowball)
    , SecondSnowball(InSecondSnowball)
    {}
    
    bool operator<(const FSnowman& InSnowman) const
    {
        return this->Height < InSnowman.Height;
    }
};

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int SnowballCount; cin >> SnowballCount;
    vector<int> SnowballDiameters(SnowballCount); for(int& Diameter : SnowballDiameters) cin >> Diameter;
    
    vector<FSnowman> Snowmans;
    for(int i = 0; i < SnowballCount - 1; ++i)
    {
        for(int j = i + 1; j < SnowballCount; ++j)
        {
            Snowmans.emplace_back(SnowballDiameters[i] + SnowballDiameters[j], i, j);
        }
    }
    
    sort(Snowmans.begin(), Snowmans.end());
    
    int MinSnowmanHeightDifference = 1e9;
    for(int Elsa = 0; Elsa < Snowmans.size() - 1; ++Elsa )
    {
        int Anna = Elsa + 1;
        
        while(Anna < Snowmans.size() 
        && (Snowmans[Elsa].FirstSnowball == Snowmans[Anna ].FirstSnowball
        || Snowmans[Elsa].FirstSnowball == Snowmans[Anna].SecondSnowball
        || Snowmans[Elsa].SecondSnowball == Snowmans[Anna].FirstSnowball
        || Snowmans[Elsa].SecondSnowball == Snowmans[Anna].SecondSnowball))
        {
            Anna++;
        }
        
        if(Anna < Snowmans.size())
        {
            MinSnowmanHeightDifference = min(MinSnowmanHeightDifference, 
            Snowmans[Anna].Height - Snowmans[Elsa].Height);
        }
    }
    
    cout << MinSnowmanHeightDifference;

    return 0;
}

[9kyo-hwang]

요거 초기값을 이런 식으로 설정하면

4
1 2 3 999

answer: 995
output: 3

이런 식으로 출력됩니당. 초기값 설정을 다시 고민해볼까요!?

[gjsk132]

오호 감사함니당

min_gap = float('inf')

근데 이정도면 치명적인데 어캐 맞췄지 테케 추가해달라칼까요🫠

[9kyo-hwang]

이제 곧 "20366번 - 같이 눈사람 만들래? 문제가 재채점 되었습니다. (재채점 이유: 데이터 추가)" 보는 걸까요 ㅋㅋㅋ

[mjj111]

오호 이 문제에서 투포인터는 양쪽 끝에서 좁혀오네요!!
애벌레처럼 한 방향으로 움직이는 투포인터 문제를 자주 풀어서 양쪽 끝은 어떻게 했었지하면서 더듬거렸습니다 ㅋㅋㅋ 🙄

코드 보기

import java.io.*;
import java.util.*;

public class Main {
    static int N; 
    static int snow[]; 
    static int min = Integer.MAX_VALUE;  

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());

        snow = new int[N];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
	        snow[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(snow);

        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                int snowMan1 = snow[i] + snow[j];

                int start = 0;
                int end = N - 1;

                while (start < end) {
                    if (start == i || start == j) {
                        start++;
                        continue;
                    }

                    if (end == i || end == j) {
                        end--;
                        continue;
                    }

                    int snowMan2 = snow[start] + snow[end];
                    min = Math.min(min, Math.abs(snowMan1 - snowMan2));

                    if (snowMan1 > snowMan2) start++;
                    else if (snowMan1 < snowMan2) end--;
                    else {
                        System.out.println(0);
                        return;
                    }
                }
            }
        }
        System.out.println(min);
    }
}