25-H0ngJu

[H0ngJu]

🔗 문제 링크

친구비

✔️ 소요된 시간

40M

✨ 수도 코드

문제요약
가장 적은 비용으로 모든 사람과 친구가 되는 방법을 구하라@!
친구 A에게 친구비를 지불하면, 친구 A와 친구관계인 친구 B도 친구가 된다

짤 쓸려고 이 문제 풀었습니다 ㅋ.ㅋ

사실 처음에 문제 보고 친구 네트워크가 생각나서 유니온-파인드로 풀 수 있을 것 같아서 시도했는데 풀다가 빠르게 돌렸습니다.

부모 노드 추가할 때마다 최소비용을 저장하려고 했는데, 잘 안되더라고요.
충분히 가능할 것 같은데..

어쨌든, 어떤 방법을 사용하든 친구관계인 사람을 모아두고 그 중에 최소를 찾으면 그만이니까 deque를 사용해서 모아두기로 했습니다.

친구는 5명, 준석이가 가지고 있는 돈은 20,
5명에 대한 각각 친구비는 10, 10, 20, 20, 30이라고 가정하겠습니다.

그리고 1-3, 2-4, 4-5가 친구관계인 경우를 생각해봅시다.
이때, 친구 관계는 relation에 저장합니다.

1-3의 경우,
relation[1]에도 3을 추가하고, relation[3]에도 1을 추가 하여 친구관계를 저장합니다.

ㄴ 저장된 relation 출력값

저장된 relation 정보를 바탕으로,
먼저 1번 친구부터 시작해서 누구와 친구 관계인지 파악해야합니다.

이때 q를 통해서 dfs로 탐색해줍니다.

그렇게 친구 관계인 N명의 사람들을 friends라는 배열에 넣고, 최소 비용을 구해주면 됩니다.

모든 관계에 대하여 최소비용을 합한 값인 total이 k값을 넘으면 "oh no"를 출력하고, 안넘으면 total을 출력해주면 됩니다.

📚 새롭게 알게된 내용

[9kyo-hwang]

아니 친구비 짤 빵터졌네 ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

[tgyuuAn]

import sys
from collections import defaultdict

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

N, M, money = map(int, input().split())
parent_cost = [(idx, cost) for idx, cost in enumerate(map(int, input().split()))]

def find_parent(graph, element):
    if element == graph[element][0]: 
        return graph[element]
    graph[element] = find_parent(graph, graph[element][0])
    return graph[element]

def union(graph, x, y):
    x_parent = find_parent(graph, x)
    y_parent = find_parent(graph, y)
    if x_parent[0] != y_parent[0]:
        if x_parent[1] < y_parent[1]:
            graph[y_parent[0]] = x_parent
        else:
            graph[x_parent[0]] = y_parent

parent = {idx: (idx, cost) for idx, cost in parent_cost}

for _ in range(M):
    fr1, fr2 = map(int, input().split())
    union(parent, fr1-1, fr2-1)
    
visited = set()
need_money = 0

for idx in range(N):
    if idx not in visited:
        stack = [idx]
        min_cost = float('inf')
        
        while stack:
            node = stack.pop()
            if node in visited:
                continue
            visited.add(node)
            min_cost = min(min_cost, parent[node][1])
            parent_node = find_parent(parent, node)[0]
            for next_node in range(N):
                if next_node != node and find_parent(parent, next_node)[0] == parent_node and next_node not in visited:
                    stack.append(next_node)
        
        need_money += min_cost

print(need_money) if need_money <= money else print("Oh no")

버스애서 유니온 파인드로 풀리겠난데? 하고 폰코딩으로 풀었씁니덧 히히

칭찬해조~~~~~!

[9kyo-hwang]

유니온 파인드 알고리즘을 최적화하는 방법으로 보통 경로 압축(Path Compreesion) 기법을 많이 사용하죠. 이것 외에도 가중치 결합(Weighted Union) 기법도 있는데요, 각 집합의 크기 정보를 이용해 집합의 크기를 균등하게 만드는 최적화 기법입니다(관련 영상).

여기서 이를 응용할 수 있는데요, 여기서는 최적화의 목적으로 사용하지 않고 문제에서 "친구의 친구는 친구"라 했으니, 같은 집합에 있는 친구들을 사귈 때는 그 중 "가장 적은 친구비"로 통일시켜도 되겠죠. 즉 집합의 크기를 나타내지 않고 가장 적은 친구비를 기록하는 용도로 사용하면 됩니다.

def main(input):
    N, M, k = map(int, input().split())
    sz = [0] + list(map(int, input().split()))  # 각 친구를 사귀는 데 필요한 비용
    p = [i for i in range(N + 1)]

    def find(x: int) -> int:
        while x != p[x]:
            p[x] = p[p[x]]
            x = p[x]
        
        return p[x]


    def union(x: int, y: int):
        x = find(x)
        y = find(y)

        if sz[x] > sz[y]:  # 친구비가 더 적은 쪽으로 결합
            p[x] = y
            sz[x] = sz[y]
        else:
            p[y] = x
            sz[y] = sz[x]


    for _ in range(M):
        v, w = map(int, input().split())
        union(v, w)

    s = set()  # 각 친구 집합 당 1명씩만 있으면 되므로 set을 이용해 기록
    ans = 0
    for friend in range(1, N + 1):
        root = find(friend)  # 각 친구 집단의 최상위 부모를 가져옴
        if root not in s:  # 이전에 만난 친구 집합이 아니라면 
            s.add(root)  # 이 집단에 속하는 친구들은 모두 사귐
            ans += sz[root]  # 그 친구 집단의 친구들을 사귀기 위한 비용

    print("Oh no" if ans > k else ans)


if __name__ == "__main__":
    main(open(0).readline)

이런 식이면 별도로 stack이나 queue를 쓸 필요 없이 반복문 한 번만 돌려주면 됩니다 :)

[alstjr7437]

다른 분들은 유니온파인드를 많이 쓰셨군요

저는 아직 유니온파인드가 익숙하지 않아서 홍주님이랑 똑같이 BFS를 이용해서 풀었습니다!!

그런데 resultMoney를 바로 하는 방법도 있었네요!!

import sys
from collections import deque

input = sys.stdin.readline

N, M, k = map(int, input().split())
student = list(map(int, input().split()))
friend = [[] for i in range(N+1)]
visited = [False] * (N+1)
resultMoney = 0

for _ in range(M) :
    a,b = map(int, input().split())
    friend[a].append(b)
    friend[b].append(a)

def bfs(start):
    queue = deque([start])
    visited[start] = True
    group_min_cost = student[start-1]
    
    while queue:
        node = queue.popleft()
        
        for neighbor in friend[node]:
            if not visited[neighbor]:
                visited[neighbor] = True
                queue.append(neighbor)
                group_min_cost = min(group_min_cost, student[neighbor-1])
    
    return group_min_cost

for i in range(1, N+1):
    if not visited[i]:
        resultMoney += bfs(i)

if resultMoney > k:
    print("Oh no")
else:
    print(resultMoney)

[alstjr7437]

cost를 다 저장해두시고 마지막에 min으로 하는 방법을 이용하셨군요!!

저는 queue안에서 돌면서 바로바로 제일 작은 부분을 넣어줬는데 이 부분도 좋아보이네요!