15-mjj111

[mjj111]

🔗 문제 링크

https://www.codetree.ai/training-field/frequent-problems/problems/codetree-tour/description?page=1&pageSize=5
코드트리 투어

✔️ 소요된 시간

1시간 20분

✨ 수도 코드

5가지 명령에 대해 아래와 같이 동작합니다.

1. 다리 건설 -> 다 연결하면 0부터 다익스트라로 값 계산
   1도시와 2도시는 3가중치 간선으로 이루어 집니다.

2. 여행 상품 생성(3만번) -> 현재 주어진 다익스트라 결과로 상품을 만듭니다.
   1고유식별자로 2매출 3도착지

3. 여행 상품 취소(3만번) -> 취소한 상품을 기록합니다.
   1고유식별자에 해당하는 여행상품을 목록에서 삭제

4. 최적의 여행 상품 판매(3만번) 관리 목록은 heap과 dict로 관리한다. -> 만약 뽑은 상품이 판매하지 않음이라면 버립니다.
   이득 - 비용이 최대치인 상품우선 고려(+id 오름차순)
   비용은 출발지로부터 id 상품의 도착지 까지 최단거리
   만약 목적지에 도달하는게 불가능하거나 비용이 이득보다 크다면 판매불가
   판매 가능한 상품중 가장 우선순위가 높은 1개를 판매하여 해당 id상품 삭제
   만약 없다면 -1 출력하고 제거 x

5. 상품 출발지 변경(15번) 출발지부터 다시 다익스트라로 값 계산 후 상품 다시 갱신/ 만약 클래스가 판매하지 않음이라면 스킵
   모든 출발지를 s로 변경 (변경함에 따라 각 상품의 비용이 변경된다)

여행 매니저 클래스를 먼저 선언해줍니다.

class TravelManager:
    def __init__(self, n):
        self.n = n  # 도시의 수
        self.graph = defaultdict(list)  # 도시 간 간선 정보
        self.distances = [INF] * n  # 0번 도시부터의 최단 거리
        self.products = {}  # 여행 상품 정보 (고유식별자 -> (매출, 도착지))
        self.unavailable = set()  # 판매되지 않는 상품의 고유식별자
        self.heap = []  # 최적의 상품 판매를 위한 힙

100 (다리건설)명령어가 먼저 주어지기 때문에 이에 대해서 Travel 매니저를 설정해주고
받는 값마다 연결한 뒤 마지막에 다익스트라를 통해 0부터 가장 짧은 길을 갱신합니다.

def main():
    q = int(input())
    input_line = list(map(int, input().split()))

    n, m = input_line[1], input_line[2]
    manager = TravelManager(n)
    creations = input_line[3:]

    for i in range(0,len(creations),3):
        creation = creations[i:i+3]
        a = creation[0]
        b = creation[1]
        cost = creation[2]
        manager.add_road(a, b, cost)  
    manager.dijkstra(0)

상품이 추가된다면 이에대해서 이미 값을 구해놨기 때문에 상품에 갱신해줍니다.

    def add_product(self, product_id, revenue, destination):
        self.products[product_id] = (revenue, destination)
        cost = self.distances[destination]
        heapq.heappush(self.heap, (-(revenue - cost), product_id))  # 최대 힙 구현

상품을 취소할 경우 취소한 목록에 넣어줍니다.

    def cancel_product(self, product_id):
        if product_id in self.products:
            self.unavailable.add(product_id)

가장 최고 상품을 판매하기 위해서 heap을 통해 출력해줍니다.
여기서 만약 이미 버린 상품이라면 continue를 통해 지나치게됩니다.

    def sell_best_product(self):
        while self.heap:
            profit, product_id = heapq.heappop(self.heap)

            if product_id in self.unavailable:
                continue  # 판매하지 않는 상품은 무시

            revenue, destination = self.products[product_id]
            cost = self.distances[destination]
            if cost == INF or cost > revenue:
                print(-1)
                return

            print(product_id)
            del self.products[product_id]
            return
        print(-1)

도착지가 변경된다면, 다시 다익스트라를 통해 값을 갱신해주고
Heapa에 있는 내용도 변경해줍니다.

    def change_departure(self, new_start):
        self.dijkstra(new_start)
        self.heap = []
        for product_id, (revenue, destination) in self.products.items():
            if product_id not in self.unavailable:
                cost = self.distances[destination]
                heapq.heappush(self.heap, (-(revenue - cost), product_id))

📚 새롭게 알게된 내용

빡구현은 화가 나지만 다 풀면 쾌감이 있네요..ㅎ
재밌는 문제였습니다.

[9kyo-hwang]

처음 낸 코드가 시간초과 나길래 쓰읍 했는데, 다시 보니 핵심은 "최적 상품"을 빨리 찾는 것이었군요...
다익스트라는 해봤자 16번밖에 발생하지 않아 우선순위큐 안 쓴 $O(N^2)$으로 해결이 되네요 허허...

#include <iostream>
#include <vector>
#include <unordered_map>
#include <queue>
using namespace std;

int main() 
{
    cin.tie(nullptr)->sync_with_stdio(false);
    constexpr int INF = 1e9;

    int Q, Cmd; cin >> Q;

    int N, M;
    vector<vector<pair<int, int>>> Graph;
    vector<int> Distances;

    priority_queue<pair<int, int>> PriorityofProducts;
    unordered_map<int, pair<int, int>> Products;

    auto Dijkstra = [&](int Start)
    {
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> PQ;
        Distances.assign(N, INF);
        
        PQ.emplace(0, Start);
        Distances[Start] = 0;

        while(!PQ.empty())
        {
            const auto [du, u] = PQ.top(); PQ.pop();
            if(Distances[u] < du) continue;

            for(const auto& [v, dv] : Graph[u])
            {
                int Distance = du + dv;
                if(Distance < Distances[v])
                {
                    Distances[v] = Distance;
                    PQ.emplace(Distance, v);
                }
            }
        }
    };

    auto Construction = [&]()
    {
        cin >> N >> M;
        Graph.resize(N);

        while(M--)
        {
            int V, U, W; cin >> V >> U >> W;
            Graph[V].emplace_back(U, W);
            Graph[U].emplace_back(V, W);
        }

        Dijkstra(0);
    };

    auto Creation = [&]()
    {
        int Id, Revenue, Dest; cin >> Id >> Revenue >> Dest;
        Products[Id] = {Revenue, Dest};

        int Cost = Distances[Dest];
        int Benefit = Revenue - Cost;
        PriorityofProducts.emplace(Benefit, -Id);
    };

    auto Cancel = [&]()
    {
        int Id; cin >> Id;
        if(Products.count(Id) > 0)
        {
            Products.erase(Id);
        }
    };

    auto Sale = [&]()
    {
        int BestProductId = -1;
        while(!PriorityofProducts.empty())
        {
            auto [Benefit, Id] = PriorityofProducts.top(); PriorityofProducts.pop();
            Id *= -1;
            
            if(Products.count(Id) == 0) continue;
            
            const auto& [Revenue, Dest] = Products[Id];
            int Cost = Distances[Dest];

            if(Cost == INF || Cost > Revenue)
            {
                BestProductId = -1;
                break;
            }

            Products.erase(Id);
            BestProductId = Id;
            break;
        }

        return BestProductId;
    };

    auto Change = [&]()
    {
        int S; cin >> S;
        Dijkstra(S);
        
        PriorityofProducts = priority_queue<pair<int, int>>();
        for(const auto& [Id, Product] : Products)
        {
            const auto& [Revenue, Dest] = Product;
            int Cost = Distances[Dest];

            PriorityofProducts.emplace(Revenue - Cost, -Id);
        }
    };

    while(Q--)
    {
        cin >> Cmd;
        switch(Cmd)
        {
            case 100: Construction(); break;
            case 200: Creation(); break;
            case 300: Cancel(); break;
            case 400: cout << Sale() << "\n"; break;
            case 500: Change();
            default: break;
        }
    }

    return 0;
}

[gjsk132]

지금까지는 구현이 재밌는 것 같은데, 위를 지키고 있는 루돌프가 두려워요 🥲

전체 코드

from heapq import *

input = open("input.txt").readline

cmd_cnt = int(input())

command = list(map(int,input().split()))[1:]

n, m = command[0], command[1]
limit = float("inf")

load_info = [[limit]*n for _ in range(n)]
dist = [limit]*n
p_id = {}
p_cost = []

for i in range(m):
    n1, n2, w = command[i*3+2:i*3+5]

    load_info[n1][n2] = min(w, load_info[n1][n2])
    load_info[n2][n1] = min(w, load_info[n2][n1])

def update_node_dist(s_node):
    
    hq = [(0, s_node)]
    check = [False]*n

    while hq and not all(check):
        w, current = heappop(hq)
        if check[current]:
            continue
        check[current] = True
        
        if w >= dist[current]:
            continue

        dist[current] = w

        for next in range(n):
            if next == current or load_info[current][next] == limit:
                continue
            heappush(hq, (w + load_info[current][next], next))

def update_product():
    update_cost = []

    for k, v in p_id.items():
        heappush(update_cost, ((dist[v[1]]-v[0]), k))
    
    return update_cost

update_node_dist(0)

for _ in range(cmd_cnt-1):
    command = list(map(int, input().split()))
    
    order = command[0]

    if order == 200:
        # 1 : id / 2 : revenue / 3 : dest
        cost = command[2] - dist[command[3]]
        heappush(p_cost, (-(command[2] - dist[command[3]]), command[1]))
        p_id[command[1]] = command[2:]

    elif order == 300:
        if command[1] in p_id:
            del(p_id[command[1]])
    
    elif order == 400:

        while True:
            if not p_cost:
                print(-1)
                break

            cost, id = heappop(p_cost)
            cost = -cost

            if not id in p_id.keys():
                continue
            
            elif cost < 0:
                heappush(p_cost, (-cost, id))
                print(-1)

            else:
                print(id)
                del(p_id[id])
            
            break
        
    else:
        dist = [limit]*n
        update_node_dist(command[1])
        p_cost = update_product()