59-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

마법의 엘리베이터

✔️ 소요된 시간

1시간

✨ 수도 코드

1. 설명

현재 나와 엘리베이터는 storey($1 \le storey \le 100,000,000$) 층에 있다. $-1, +1, -10, +10, -100, +100, ...$과 같이 절대값이 $10^c$($c \ge 0$) 형태인 정수들이 적힌 버튼 엘리베이터를 통해 0층으로 가고자 한다.
해당 버튼을 누르면 현재 층 수에 버튼에 적혀 있는 값을 더한 층으로 이동하게 되는데, 엘리베이터가 위치해 있는 층과 버튼의 값을 더한 결과가 0보다 작으면 엘리베이터는 움직이지 않는다.

엘리베이터를 움직이기 위해서 버튼 한 번당 마법의 돌 한 개를 사용한다.

• 예를 들어, 16층에서 0층으로 가려면 -1이 적힌 버튼을 6번, -10이 적힌 버튼을 1번 눌러 마법의 돌 7개를 소모하여 0층으로 갈 수 있다.
• 하지만, +1이 적힌 버튼을 4번, -10이 적힌 버튼 2번을 누르면 마법의 돌 6개를 소모하여 0층으로 갈 수 있다.

이와 같이 어떤 층에서 엘리베이터를 타고 0층으로 내려가는데 필요한 마법의 돌의 최소 개수를 알고자 한다.
현재 층을 나타내는 정수 storey가 주어졌을 때, 0층으로 가기 위해 필요한 마법의 돌의 최소값을 return 하도록 solution 함수를 완성하라.

2. 풀이

처음에 문제를 딱 보자마자 1로 만들기 문제나 숨바꼭질 거의 비슷해 보여서 거리 테이블과 queue를 이용한 BFS로 풀려고 했으나...

BFS 시도 코드

#include <vector>
#include <queue>
#include <unordered_map>
#include <cmath>

using namespace std;

int solution(int Storey) 
{
    vector<int> Buttons;
    int Button;
    for(int c = 0; (Button = pow(10, c)) < Storey; ++c)
    {
        Buttons.emplace_back(Button);
        Buttons.emplace_back(-1 * Button);
    }
    
    deque<int> Q;
    unordered_map<int, int> Consumptions;
    
    Q.emplace_back(Storey);
    Consumptions[Storey] = 0;
    
    while(!Q.empty())
    {
        const int Floor = Q.front();
        Q.pop_front();
        
        if(Floor == 0) break;

        for(const int Button : Buttons)
        {
            int NextFloor = Floor + Button;
            if(NextFloor >= 0 && Consumptions.count(NextFloor) == 0)
            {
                Consumptions[NextFloor] = Consumptions[Floor] + 1;
                Q.emplace_back(NextFloor);
            }
        }
    }
    
    return Consumptions[0];
}

거의 모든 테케에서 시간 초과가 발생했다.
1로 만들기는 무조건 숫자가 감소하는 것밖에 없기 때문에 케이스를 귀결시킬 수 있었고, 숨바꼭질은 숫자 범위가 좁기 때문에 벗어나는 케이스를 많이 거를 수 있었지만 이 문제는 아니었다...
결국 삽질 좀 하다가 다 지우고 질문 게시판을 확인해보고 나서 감을 잡았다.

핵심은 "끝자리 숫자를 확인해서 더하기/빼기 수행하기"이다.

1. 예를 들어 16의 경우 아래와 같이 수행해서 6번이 최소이다.

• 16 -> 20(+1 4번)
• 20 -> 0(-10 2번): 20에서 -10 * 2번 == 2에서 -1 * 2번.

2. 예를 들어 2554의 경우 아래와 같이 수행해서 16번이 최소이다.

• 2554 -> 2550(-1 4번)
• 2550 -> 2600(+10 5번): 2550에서 +10 * 5번 == 255에서 +1 * 5번
• 2600 -> 3000(+100 4번): 2600에서 +100 * 4번 == 26에서 +1 * 4번
• 3000 -> 0(-1000 4번): 3000에서 -1000 4번 == 3에서 -1 * 4번

예시를 보면 알 수 있듯, 뒤에 0이 붙어있는 경우는 사실상 떼고 생각해도 무방하다는 것을 알 수 있다.
주의해서 봐야할 점은 숫자가 "5"인 경우인데

• 0 ~ 4는 -1을 수행하면 된다.
• 6 ~ 9는 +1을 수행하면 된다.
• 5의 경우 "다음 자리가 5 이상이면 +1, 아니라면 -1"을 수행한다.

예를 들어, 65를 0으로 만든다고 하면

• 65 -> 70(+1 5번) -> 100(+10 3번) -> 0(-100 1번): 9번
• 65 -> 60(-1 5번) -> 100(+10 4번) -> 0(-100 1번): 10번

이렇게 5에서 +1/-1 하는 거에 따라 횟수가 달라지는데, +1 하는 것이 더 횟수가 적음을 알 수 있다. 이는 앞 자리가 "6"인 것을 보고 +1을 했기 때문이다.

이 규칙을 주의해서 코드를 작성하면 된다.

int solution(int Storey) 
{
    int Answer = 0;
    
    while(Storey)
    {
        int Remainder = Storey % 10;
        int Quotient = Storey / 10;
        
        if(Remainder < 5)  // 끝자리 숫자가 0 ~ 4
        {
            Answer += Remainder;  // 숫자만큼 -1
        }
        else if(Remainder > 5)  // 끝자리 숫자가 6 ~ 9
        {
            ++Quotient;  // 자릿수 올림이 발생함
            Answer += 10 - Remainder;  // 숫자만큼 +1
        }
        else  // 끝자리 숫자가 5
        {
            if(Quotient % 10 >= 5)  // 다음 자리 숫자가 5 이상이면
            {
                ++Quotient;  // +1을 해야하므로 자릿수 올림
            }
            
            Answer += Remainder;  // 숫자만큼 +1/-1
        }
        
        Storey = Quotient;  // 갱신된 몫으로 갱신
    }
    
    return Answer;
}

코드는 간단하다. 위에서 얘기한 케이스를 그대로 구현한 것이다.
끝 자릿수를 그때그때 확인해서 5 초과 / 5 미만 / 5 3가지 경우로 나눠 몫을 보정한 뒤 버튼 누른 횟수를 더해주면 된다.

📚 새롭게 알게된 내용

약간 조이스틱 문제랑 비슷한 것 같기도 하다...

[tgyuuAn]

def solution(storey):
    
    answer = 0
    flag = False
    storey = str(storey)
    for y in range(len(storey)-1,-1,-1):
        x = int(str(storey)[y])
        
        if(flag == True):
            x += 1
            flag = False
            
        if(y==0):
            if x>=6: answer += 10-x+1
            else: answer += x
            return answer

        if(x>=6):
            answer += (10 - x)
            flag = True
            
        elif(x<=4): answer += x
        
        else:
            if y>=1:
                if int(storey[y-1])>=5:
                    answer += (10 - x)
                    flag = True
                else: answer += x

싫어하는 유형의 문제..

[mjj111]

5일 때, 5증가시킬지 5를 빼버릴지 경계선 찾는데 헤맸네요 ㅋㅋㅋ ㅠ
시험장에서 실제로 만나면 등골 오싹할 듯합니다..ㅎ

def solution(storey):
    answer = 0
    carry = False 
    numbers = list(str(storey))[::-1]  
    n = len(numbers)
    
    for i in range(len(numbers)):
        now = int(numbers[i]) + carry
        answer += now
        carry = False 
        
        if now > 5:
            answer -= (-10 + now*2)
            carry = True
            continue 
            
        if now == 5 and i != n-1:
            next = int(numbers[i+1])
            if next >= 5 :
                carry = True 
            continue 
            
    if carry:
        answer += 1
    
    return answer