16-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[퍼즐 게임 챌린지]

✔️ 소요된 시간

48m

✨ 수도 코드

PCCP 기출문제 2번입니다.

문제를 읽어보시면 구현 + 탐색 방법 중 하나 라는 생각이 들 것 입니다.
저는 적절한 level이 나올 때 까지 퍼즐을 푸는로직을 반복하는 그런 솔루션이 떠올랐습니다.

여기서 퍼즐을 푸는 은 구현 이라고 생각이 되고,
적절한 level을 찾는건 탐색이라고 생각 되네요.

구현은.... 각자의 몫입니다...
문제를 읽어보면 이런 로직을 떠올릴 수 있어야 할 것 같네요!

long long prev = level - diffs[i];
if (prev < 0) time += -prev * (times[i-1] + times[i]);
time += times[i];

(아마 더 간결하거나 한눈에 보기 쉬운 구현방법이 있겠죠?)

이제 진짜 문제는 탐색입니다. 적절한 level 찾기방법은 여러가지가 있을 수 있어요.

1. level을 1부터 limit까지 증가시키며, time이 처음 limit를 넘어설 때의 level값 이 정답
2. level을 이분 탐색하며 start > end 가 되었을 때의 level값 이 정답
.
.
.

저는 처음에는 1번 방식으로 빠르게 구현해봤습니다. (처음에는 이분탐색이 떠오르지 않았습니다ㅜ)
아니나 다를까 시간초과, 몇 몇 케이스 에서는 오답까지 나더라구요.

탐색에 문제가 있다는 것을 알게되었고, 이분탐색으로 진행해보았었습니다.
그런데... 이분탐색을 구현하지 못하겠더라고요.....

정확히 말하면 이분탐색 자체는 구현했는데 여전히 몇몇 케이스에서는 오답이었습니다.
그래서 다른사람의 풀이 한 번 봤습니다.

역시 이분탐색 이었고, 등호 같은 것에 문제가 있었습니다!
대소를 비교하는 일부 코드에 등호가 있고 없고의 차이가 났었더라고요.
그것을 고치니 정답이었습니다.

📚 새롭게 알게된 내용

탐색할 범위가 넓을 경우에는 BinarySearh를 활용하자!
BinarySearh를 활용할 때는 break하는 조건, start = mid +1하는 조건, end = mid -1하는 조건을 잘 정하자!

[g0rnn]

처음에 일반적인 탐색을 사용했을 때 테스트 케이스가 4개만 실패해서 뭐가 문제지 고민하고 있었는데 강래님의 코드를 보니 이진탐색인 걸 깨닫고 바로 바꿨습니다.

바꾸면서 들었던 의문은 어떻게 답을 찾지? 였습니다. 저는 문제를 처음 접근할 때 가장 먼저 찾는 level 값이 답이라고 생각했습니다. 높은 level은 모든 퍼즐을 쉽게 해결하고 제한 시간내에 반드시 풀 수 있기 때문에 level을 가장 먼저 찾는게 중요하다고 생각했습니다. 그래서 다음의 코드가 나왔습니다.

처음 코드

//
// Created by 김균호 on 2025. 1. 18..
//
#include <string>
#include <vector>
#include <iostream>
#include <climits>

using namespace std;

long long measure(const vector<int> &diffs, const vector<int> &times, int level, long long limit) {
    int size = diffs.size();
    long long total = 0;
    for (int i = 0; i < size; i++) {
        if (level >= diffs[i]) total += times[i];
        else total += (times[i - 1] + times[i]) * (diffs[i] - level) + times[i];
        if (total > limit || total < 0) return -1; // overflow
    }
    return total;
}

// 제한시간 내에 퍼즐을 해결하기 위한 숙련도의 최솟값
// 1부터 level을 올려가면서 퍼즐이 시간내에 해결되는 숙련도를 찾으면 그것이 최솟값이 됨
int solution(vector<int> diffs, vector<int> times, long long limit) {
    int level;
    for (level = 1; level <= 100000; level++) {
        long long time = measure(diffs, times, level, limit);
        if (time <= limit && time != -1) break;
    }
    return level;
}

그래서 이진 탐색에 대한 의문을 품었지만.. 일단 문제는 풀렸습니다. 왜 답이 찾아지는지는 좀 더 생각해봐야겠어요

code

#include <string>
#include <vector>

using namespace std;

long long measure(const vector<int>& diffs, const vector<int>& times, int level, long long limit) {
    int size = diffs.size();
    long long total = 0;
    for (int i=0; i<size; i++) {
        if (level >= diffs[i]) total += times[i];
        else total += (times[i-1] + times[i]) * (diffs[i]-level) + times[i];
        if(total < 0) return -1; // overflow
    }
    return total;
}

int solution(vector<int> diffs, vector<int> times, long long limit) {
    int m;
    int s = 1, e = 100000;
    while(s<=e) {
        m = (s+e)/2;
        long long time = measure(diffs, times, m, limit);
        if(time > limit) s = m+1;
        else e = m-1;
    }
    return s;
}

[g0rnn]

이진탐색을 통해서 level을 찾아가니 end는 level의 최댓값인 100000이라고 생각합니당

[g0rnn]

지금 생각해보니 이진탐색이 가능한 이유는 if(time > limit)에서 퍼즐을 시간내에 풀수 있더라도 최소 level을 구하기 위해 e = m-1을 통해 더 작은 level을 통해 퍼즐을 풀 수 있는지 계속 확인하는 로직 때문이군요!

[kangrae-jo]

이진탐색을 통해서 level을 찾아가니 end는 level의 최댓값인 100000이라고 생각합니당

오 그렇네요! 순간 limit 변수의 의미를 혼용해버렸었나봐요 감사합니다~

지금 생각해보니 이진탐색이 가능한 이유는 if(time > limit)에서 퍼즐을 시간내에 풀수 있더라도 최소 level을 구하기 위해 e = m-1을 통해 더 작은 level을 통해 퍼즐을 풀 수 있는지 계속 확인하는 로직 때문이군요!

정확히 이해는 안되지만 그런 느낌은 맞습니다. 상한과 하한을 계속 조절하며 최소 level을 찾는 원리입니다!

[wnsmir]

일단 결론은 틀렸습니다..
생각나는대로 일단 로직에 맞게 diffs중 최고 난이도를 level로 잡고 점차 하나씩 내려가며 난이도가 높아질수록 시간이 늘어나 limit을 초과하게 될때, 직전의 level을 반환해 답을 찾는 방법으로 풀었습니다.

4개짜리 정답은 전부 통과했지만, 제출후 체점에서는 절반의 답만 구할 수 있었습니다.
나머지는 전부 시간초과였습니다.

몇번째PR인지는 기억이 잘 나지 않는데, 제가 올렸던 문제같습니다. (서울 올라가기 직전에 올렸던 PR 같습니다. 그때도 이런문제였는데 이분탐색을 활용해 풀었던 기억이 납니다.

처음에는 level을 1과 max(diffs)로 잡습니다.
이후 절반의 값으로 건너뛰어 가능하다면 왼쪽의 절반, 불가능하다면 오른쪽의 절반으로 건너뛰며 level을 찾는것입니다.

mid = (left + right) // 2
만약 limit을 넘지 않는다면?
level이 더 내려가도 가능하다는 뜻이므로 right는 mid-1이 됩니다.(중앙값보다 작은수로 전체를 줄임)

def solution(diffs, times, limit):
    high_level = max(diffs)
    level = high_level
    min_level = 0
    timetable = []
    current = 0
    
    for i in range(len(times)):
        if i == 0:
            timetable.append(times[i])
        else:
            timetable.append(times[i-1] + times[i])
        
    while level >= 0:
        total_time = 0
        for i in range(len(diffs)):
            if level >= diffs[i]:
                total_time += times[i]
            else:
                total_time += timetable[i] * (diffs[i] - level) + times[i]

        if total_time <= limit:
            min_level = level
        else:
            break
            
        level -= 1
                    
    answer = min_level
    return answer