39-Munbin-Lee

[Munbin-Lee]

🔗 문제 링크

https://www.acmicpc.net/problem/1050

임문빈을 검색해서 나온 문제를 풀어보았습니다.

✔️ 소요된 시간

1시간

✨ 수도 코드

문제 설명

예제 입출력을 먼저 보면 빨리 이해할 수 있다.

---

재료의 이름은 알파벳이므로, 선택지가 하나밖에 없다. dict를 사용하여 저장한다.

prices = {}

for _ in range(N):
    item, price = input().split()
    prices[item] = int(price)

---

레시피는 2가지 방법으로 저장할 수 있다.

1. 각 레시피를 리스트에 그냥 연결하여 저장한다.

ex. [['LOVE', ['2WATER', '4HONEY', '2BEER']], ['BEER', ['1HOP', '3WATER', '1HOP']]]

2. defaultdict를 사용하여 각 물약에 해당하는 레시피들을 저장한다.

defaultdict['LOVE'] = [['2WATER', '4HONEY', '2BEER'], [...]]
defaultdict['BEER'] = [['1HOP', '3WATER', '1HOP'], [...]]

문제를 풀다보니 딱히 특정 물약에 해당하는 레시피를 사용할 필요가 없어 1번 방법으로 저장했다.

이 부분은 시행착오를 거칠 수 밖에 없을 것 같다.

for _ in range(M):
    target, formula = input().split('=')
    terms = formula.split('+')
    recipes.append([target, terms])

---

각 물약의 비용을 구하는 방법은 직관적이다.

레시피에 있는 각 재료의 수 * 각 재료의 비용을 더하면 된다.

def updatePrice(target, terms):
    price = 0
    
    for term in terms:
        count = int(term[0])
        item = term[1:]
        
        if item not in prices:
            return
        
        price += count * prices[item]
    
    if target not in prices or prices[target] > price:
        prices[target] = price

---

그러나 한 가지 고려해야 할 점이 있다.

물약의 재료로 다른 물약이 포함된 경우이다.

1번 예제를 보면 LOVE의 재료에 BEER이 있다.

만약 처음 레시피부터 차례대로 updatePrice()를 한다면,

updatePrice('BEER')의 시점은 updatePrice('LOVE') 이후이기 때문에

LOVE의 비용을 구할 수 없다.

그래서 위상정렬처럼 순서를 정해서 구해야하나? 생각하다가 상호 참조 등 복잡한 경우가 있을 것 같아 다른 방법을 생각하였다.

---

레시피의 개수는 고작 50개이다.

따라서 모든 레시피를 순회하면서 updatePrice()를 한다.

만약 1개라도 특정 재료의 비용이 업데이트(새로 생기거나, 이전보다 싸졌거나)되었다면

다시 50개를 모두 순회한다.

이 과정을 반복한다.

이를 위해 updatePrice()의 반환값을 bool로 변경하였다.

def updatePrice(target, terms):
    price = 0
    
    for term in terms:
        count = int(term[0])
        item = term[1:]
        
        if item not in prices:
            return False
        
        price += count * prices[item]
    
    if target in prices and prices[target] <= price:
        return False
    
    prices[target] = price
    return True

그리고, 루프 여부를 결정하는 변수 loop를 or 연산하여 한 번이라도 업데이트되면, 전체 레시피를 다시 순회한다.

loop = True

while loop:
    loop = False
    
    for recipe in recipes:
        loop |= updatePrice(recipe[0], recipe[1])

---

혹은 이런 방법도 가능하다.

결과가 정해지기 전까지, 각 루프를 돌 때마다 최소 1개의 물약의 비용은 업데이트된다.

따라서, 레시피의 갯수만큼 루프를 그냥 돌면 된다.

위의 방법보다 아주 아주 아주 살짝 비효율적이다.

for _ in range(M):
    for recipe in recipes:
        updatePrice(recipe[0], recipe[1])

---

그리고 이건 생각만 해본 방법인데, 레시피를 파싱할 때에 재료의 사용처를 저장한다.

1번 예제를 예로 들면,

references['WATER'] = ['LOVE', 'BEER']
references['HONEY'] = ['LOVE']
references['BEER'] = ['LOVE']
references['HOP'] = ['BEER']

이렇게 된다.

그리고, 각 비용이 업데이트 될 때마다 그 레퍼런스를 dict에 저장한다.

그리고 그 dict를 다시 순회하고, 그 레퍼런스를 다른 dict에 저장하는 것을 반복한다.

이론상 가장 효율적인 방법이지만 구현하기 까다롭다.

무엇보다도 worst case에서는 효과가 없기 때문에 굳이 구현해보지는 않았다.

📚 전체 코드

stdin = open(0)

def input():
    return stdin.readline().rstrip()

N, M = map(int, input().split())

prices = {}

for _ in range(N):
    item, price = input().split()
    prices[item] = int(price)

recipes = []

for _ in range(M):
    target, formula = input().split('=')
    terms = formula.split('+')
    recipes.append([target, terms])

def updatePrice(target, terms):
    price = 0
    
    for term in terms:
        count = int(term[0])
        item = term[1:]
        
        if item not in prices:
            return False
        
        price += count * prices[item]
    
    if target in prices and prices[target] <= price:
        return False
    
    prices[target] = price
    return True

loop = True

while loop:
    loop = False
    
    for recipe in recipes:
        loop |= updatePrice(recipe[0], recipe[1])

if 'LOVE' not in prices:
    print('-1')
    exit()

answer = min(prices['LOVE'], 1000000001)
print(answer)

[Hwangyerin]

임문빈은 이름이 LOVE인 마법의 물약을 만들려고 한다. (이 물약을 먹으면 임문빈을 사랑하게 된다) 시장에서 파는 재료와 그 가격이 주어지고, 임문빈이 만들 수 있는 모든 물약의 식이 주어진다. 이때, LOVE를 1만큼 만드는데 드는 비용의 최솟값을 출력한다.

백준의 과학자 임문빈씨는 관심분야가 사랑이군요. 아니면 백준이 임문빈씨를 어떻게든 사랑하게 만드는건가.?🤔

[tgyuuAn]

import sys
from collections import defaultdict

MAX = 1000000001

def input(): return sys.stdin.readline().rstrip()

N, M = map(int, input().split())

cost = defaultdict(lambda : int(1e9))
receipes = defaultdict(list)
for _ in range(N):
    ingredient, ingredient_cost = input().split()
    cost[ingredient] = int(ingredient_cost)

for _ in range(M):
    result, receipe = input().split("=")
    ingredients = receipe.split("+")
    
    receipes[result].append(list((int(ingredient[0]), ingredient[1:]) for ingredient in ingredients))

def find_the_cheapest_cost(ingredient, receipes, cost, parent, cache):

    # 레시피도 없고 살 수도 없을 경우 -1을 반환
    if len(receipes[ingredient]) == 0 and cost[ingredient] == int(1e9): return -1
    
    # 제조할 수 없을 경우 살 수 밖에 없음
    if len(receipes[ingredient]) == 0: return cost[ingredient]

    parent.add(ingredient)

    for love_receipe in receipes[ingredient]:
        
        accumulate = 0
        flag = False
        for (count, sub_ingredient) in love_receipe:
            
            # 만약, 내부 재료에 부모 재료가 들어갈 경우, 사이클을 만드므로 재조를 그만 둠
            if sub_ingredient in parent: 
                flag = True
                break
                
            sub_ingredient_cost = min(MAX,find_the_cheapest_cost(sub_ingredient, receipes, cost, parent, cache))
            
            # 내부 재료를 사지도, 만들지도 못할 경우 제조를 그만 둠
            if sub_ingredient_cost == -1: 
                flag = True
                break
            
            if sub_ingredient_cost == MAX: accumulate = MAX
            else: accumulate += min(MAX,count * sub_ingredient_cost)
        
        # for문 안에서 break를 타지 않았을 경우, 즉 내부 재료를 모두 구할 수 있는 경우
        else: 
            if cost[ingredient] == int(1e9) and accumulate > int(1e9): cost[ingredient] = MAX
            elif cost[ingredient] == -1: cost[ingredient] = accumulate
            else: cost[ingredient] = min(cost[ingredient], accumulate)
            
        # 만약 내부 재료에 부모 재료가 들어있어서 재조를 못할 경우 -1을 반환 함
        if flag and cost[ingredient] == int(1e9): cost[ingredient] = -1

    parent.discard(ingredient)
    
    return cost[ingredient]

print(find_the_cheapest_cost("LOVE", receipes, cost, {"LOVE"}, cache))

일단 1시간 째 이긴 한데,

질문 게시판 반례를 다 통과하는데 시간 초과가 나네요.

LOVE부터 재료를 타고타고 가면서 계속 최소 값을 찾아나가는 로직인데,

문빈님이 말하셨던 방법이네요.

근데 시간 초과가 왜 나는건지 ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ

문빈님 풀이 보면서 다시 풀어보겠습니다....... 화가 나네요 😠😠😠

---

문빈님 풀이 굉장히 직관적이고 제 풀이보다 훨씬훨씬훨씬 쉽네요.

흡수했씁니다.

import sys
from collections import defaultdict

def input(): return sys.stdin.readline().rstrip()

N, M = map(int, input().split())

cost = defaultdict(lambda : int(1e9))
receipes = defaultdict(list)
for _ in range(N):
    ingredient, ingredient_cost = input().split()
    cost[ingredient] = int(ingredient_cost)

for _ in range(M):
    result, receipe = input().split("=")
    ingredients = receipe.split("+")
    
    receipes[result].append(list((int(ingredient[0]), ingredient[1:]) for ingredient in ingredients))

def update_price(target, receipes, cost):
    loop_flag = False
    
    for receipe in receipes:
        
        accumulate = 0
        for (count, ingredient) in receipe:

            if ingredient not in cost: break
            
            accumulate += (count * cost[ingredient])
        
        else:
            if target not in cost or accumulate < cost[target]:
                loop_flag = True
                cost[target] = accumulate

    return loop_flag

loop_flag = True

while loop_flag:
    loop_flag = False
    
    for target in receipes:
        loop_flag |= update_price(target, receipes[target], cost)

print(min(1000000001,cost["LOVE"])) if "LOVE" in cost else print("-1")

[pknujsp]

요 문제 며칠동안 틈틈이 팠는데 결국 기본 테스트 케이스도 못 맞추겠어서
문빈님 풀이 보고 공부한 뒤에 다시 풀어봐야 겠네요

너무 어렵네요 이거