55-tgyuuAn

[tgyuuAn]

🔗 문제 링크

친구 네트워크

✔️ 소요된 시간

40분

✨ 수도 코드

알고리즘 미리보기 방지용 랫서팬더 입니둥

선행적으로 알고리즘 노트 에 있는 서로소 집합 개념을 알고 있어야 합니다.

(흔히 유니온 파인드라고 부릅니다.)

유니온 파인드 개념을 모르면 풀 수 없습니다....!

위에 알고리즘 노트 보시고 추천 문제를 풀어보신 뒤에 이 문제를 풀어보시기를 추천드립니다!

기존 유니온 파인드가 인덱스로 부모 항을 판별했더라면,

이 문제는 해쉬 값으로 부모를 판별합니다.

그 것말고는 딱히 더 어려운 부분은 없습니다.

처음에 아래와 같이 부모 정보가 있다고 해봅시다.

당연히 초기에는 정보가 없으니 비어있을 것 입니다.

그 다음으로 Barney와 Fred가 친구라는 정보가 주어졌습니다.

둘 중에 하나를 기준으로 부모 정보를 갱신시켜 줍니다.

(이 때 대부분의 언어에서도 문자열도 min 혹은 max가 먹힐 것 입니다.)

그 다음으로 Barney와 Betty가 친구라는 정보가 또 들어옵니다.

그럼 아래 그림처럼 될 것 입니다.

마지막으로 wilma와 Betty가 친구라는 정보가 들어옵니다.

그럼 아래 그림처럼 될 것 입니다.

이 때, 각 친구 정보가 주어졌을 때 두 사람의 친구 네트워크에 몇 명이 있는 지 어떻게 구하느냐 ?

매번 union-find를 할 때 마다 모든 항을 뒤져볼 경우 시간 초과가 납니다

어떻게 알았냐고요?

저도 알고 싶지 않았어요.

그렇기 때문에 각 부모 노드를 기준으로 몇 명의 친구 네트워크가 형성되어 있는 지를 미리 계산을 해 놓아야 합니다.

주석은 성훈님을 위해 써놓았어요.

for _ in range(T):
    F = int(input())
    index = 1
    parent = defaultdict(str)

    # 해쉬 맵에 처음 들어갈 때 값을 1로 설정하는 코드 입니다.
    count = defaultdict(lambda : 1)
    
    for _ in range(F):
        first, second = input().split()
        
        # 만약 해쉬 맵에 처음 들어가는 값일 경우 부모 노드를 자기 자신으로 설정하는 코드입니다.
        if parent[first] == "": parent[first] = first                          
        if parent[second] == "": parent[second] = second
     
        if parent[first] != parent[second]: union(first, second, parent, count)

위 코드처럼 초기 항이 들어갈 때 count에 각 노드가 1로 설정되게 한 다음,

union 과정에서 자식 노드의 count 값을 부모 노드의 count로 병합 시켜주면 됩니다.

def union(first, second, graph, count):
    x = find_parent(first, graph)
    y = find_parent(second, graph)

    if x == y: return

    x, y = min(x, y), max(x, y)
    graph[y] = x
    count[x] += count[y]
    count[y] = 0
    return

이러면 매 단계마다 일일이 모든 노드를 탐색할 필요가 없어져요!

📚 새롭게 알게된 내용

[9kyo-hwang]

각 트리(집합)의 무게(크기)를 저장하는 것이 비단 이 문제만의 키는 아니긴 합니다.
union-find 알고리즘을 최적화하는 2가지 방법이 있는데, 하나가 잘 알려진 "Path-Compression"이고 다른 하나가 이 문제에서 쓰인 "Weighted Union" 입니다.
통상적인 union-find 문제들은 path-compression만 적용시켜도 어지간하면 시간 문제가 다 해결됩니다만.... 한 번쯤은 그래도 확인해놓는 것도 좋을 것 같아요 :)

[H0ngJu]

유니온 파인드..... 처음 봤어요 허허
이번 기회에 공부하고 갑니닷 ~! ~!

이 문제 풀기 전에 다른 쉬운 예제 풀려고 찾아봤는데 다 골드 문제 뿐이네요 쩝...
다른 문제들도 도전해보겠슴다
유니온 파인드

수고하셨슴다 ~~ 😎💪

import sys
from collections import defaultdict

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

def find(x): # 부모 찾기
    if parent[x] != x: # 계속 거슬러 올라가기
        parent[x] = find(parent[x])
    return parent[x]


def union(a, b):
    a = find(a)
    b = find(b)

    if a != b:
        parent[b] = a
        network[a] += network[b]
    return network[a]


for _ in range(int(input())):
    num = int(input())
    parent = defaultdict(str)
    network = defaultdict(lambda : 1)

    for i in range(num):
        a, b = input().split()
        if a not in parent: # 부모에 등록되지 않은 경우
            parent[a] = a
        if b not in parent:
            parent[b] = b
        print(union(a, b)) # 친구 관계 합치기

[H0ngJu]

혹시 합치는 과정에서 count[y]를 초기화 해주는 이유가 있나요??

[tgyuuAn]

@H0ngJu

왠지 한번 부모 노드로 병합된 친구들이 추후에 다시 사용될 것 같다는 생각이 들어서 초기화를 했는데 그럴 경우는 없나요 ...?

저 줄 빼도 통과하긴 하네요 ,,,

[H0ngJu]

이렇게 default값 지정이 되는군요

network[a] = 1

로 했다가 바로 수정했습니다 ㅎㅅㅎ

[tgyuuAn]

@H0ngJu 🫡🫡🫡

[SeongHoonC]

어.. 제가 푼게 union find 가 맞는지는 모르겠는데 비슷하게 푼 것 같아요!
head 를 찾아서 그 head끼리 비교해서 더 작은 것으로 count 병합합니다.
설명하고 보니깐 똑같은 것 같은데 제 코드가 조금 복잡하네용..!

import java.io.BufferedReader
import java.io.InputStreamReader

private lateinit var br: BufferedReader
fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))
    val t = br.readLine().toInt()
    repeat(t) {
        makeNetwork()
    }
}

private fun makeNetwork() {
    val f = br.readLine().toInt()
    val network = mutableMapOf<Int, Int>()
    val friendIndex = mutableMapOf<String, Int>()
    val count = mutableMapOf<Int, Int>()

    var index = -1
    repeat(f) {
        val (a, b) = br.readLine().split(" ")
        val aIndex: Int = friendIndex.getOrPut(a) {
            index++
            network[index] = index
            count[index] = 1
            index
        }
        val bIndex: Int = friendIndex.getOrPut(b) {
            index++
            network[index] = index
            count[index] = 1
            index
        }

        var aHead = network[aIndex]!!
        while (aHead != network[aHead]) {
            aHead = network[aHead]!!
        }
        var bHead = network[bIndex]!!
        while (bHead != network[bHead]) {
            bHead = network[bHead]!!
        }

        if (aHead == bHead) {
            println(count[aHead])
        } else if (aHead < bHead) {
            network[bHead] = aHead
            count[aHead] = count[aHead]!! + count[bHead]!!
            println(count[aHead])
        } else {
            network[aHead] = bHead
            count[bHead] = count[aHead]!! + count[bHead]!!
            println(count[bHead])
        }
    }
}

[alstjr7437]

defaultdict를 처음 보게 되서 어떤건지 찾아봤는데
딕셔너리 인수를 초기화하여 사용하는데 사용 되더군요!!!
매번 그냥 초기화할때 억지로 값을 넣어줘서 사용했는데 사용하면 편할 것 같네요!!
지식이 늘어났습니다!!!!! 감사합니다!!

text = "Life is too short, You need python."

d = dict()
for c in text:
    if c not in d:
        d[c] = 1
    else : 
        d[c] += 1

print(d)

from collections import defaultdict

text = "Life is too short, You need python."

d = defaultdict(int)

for c in text:
    d[c] += 1

print(dict(d))

{'L': 1, 'i': 2, 'f': 1, 'e': 3, ' ': 6, 's': 2, 't': 3, 'o': 5, 'h': 2, 'r': 1, ',': 1, 'Y': 1, 'u': 1, 'n': 2, 'd': 1, 'p': 1, 'y': 1, '.': 1}

[tgyuuAn]

@alstjr7437 🫡🫡🫡

그거 엄청 엄청 유용한 거니까 체화 하도록하시지요 ~~👍👍👍