Merge pull request #55 from bsa0322/jy/union-find/py

[유니온 파인드] 05월 26일 (필수 + 선택)

Author: bsa0322

05월 24일 - 유니온 파인드/과제/1043.py

@@ -0,0 +1,69 @@
+import sys
+sys.setrecursionlimit(10**6)
+input = sys.stdin.readline
+
+"""
+ [거짓말]
+
+ 1. 각 사람들은 다양한 파티를 통해 연결됐다고 할 수 있음
+ 2. 연결된 사람들은 같은 집합에 속함
+ 3. 각 집합에 속한 사람들 중 한 명이라도 진실을 안다면 그 집합의 사람들이 속한 파티에는 거짓말을 할 수 없음
+ -> 유니온 파인드로 사람들을 집합으로 묶은 뒤, 파티마다 거짓말을 할 수 있는지 확인하기
+ -> 이때, 진실을 아는 사람들의 루트 정점을 0으로 설정해서 유니온 파인드를 통해 집합으로 묶고 시작
+ -> 0과 같은 집합이 아니어야 거짓말을 할 수 있음
+
+ !주의! 파티 정보를 입력받으며 바로 거짓말 가능 여부를 판단할 수 없음 (예제 입력 4)
+       각 파티에서 한 사람만 저장해둔 뒤, 마지막에 거짓말 가능 여부 한 번에 판단
+"""
+
+# find 연산
+def find_parent(x):
+    if parent[x] < 0:
+        return x
+    parent[x] = find_parent(parent[x])
+    return parent[x]
+
+# union 연산
+def union(x, y):
+    px = find_parent(x)
+    py = find_parent(y)
+
+    if px == py:
+        return
+
+    if parent[px] < parent[py]:
+        parent[px] += parent[py]
+        parent[py] = px
+    else:
+        parent[py] += parent[px]
+        parent[px] = py
+    return
+
+def count_liar_party(party):
+    cnt = 0
+
+    for i in party:
+        if find_parent(i) != find_parent(0):
+            cnt += 1
+    
+    return cnt
+
+# 입력
+n, m = map(int, input().split())
+parent = [-1] * (n+1)     # 초기화
+
+party = []  # 각 파티의 대표자 저장할 리스트
+
+# 진실을 아는 사람들
+for i in map(int, input().split()[1:]):
+    union(i, 0)
+
+# 각 파티에 대한 입력 & 연산
+for _ in range(m):
+    arr = list(map(int, input().split()))
+    party.append(arr[1])    # 파티 정보로 각 파티의 첫번째 사람만 저장
+    for i in range(2, arr[0] + 1):
+        union(arr[i], arr[1])
+
+# 연산 & 출력
+print(count_liar_party(party))

05월 24일 - 유니온 파인드/과제/12100.py

@@ -0,0 +1,90 @@
+import sys
+input = sys.stdin.readline
+
+"""
+ [2048 (Easy)]
+
+ - 상, 하, 좌, 우로 이동하는 경우에 대해 최대 5번 이동시키는 모든 경우를 구한 후, 가장 큰 블록 찾는 문제 - 백트래킹
+ - 움직이는 함수는 하나만 짜고, 보드를 돌려가면서 상, 하, 좌, 우 모든 방향의 움직임을 만듦
+
+ - 상 <-> 하: 행 순서를 뒤집어서 해결
+ - 상/하 <-> 좌/우: Transpose Matrix 활용
+
+ - ex. 2 2 1 를 상, 하, 좌, 우로 이동하는 경우 구하는 법
+       2 2 2
+       4 4 4
+  -상: 원래 배열에서 상으로 움직이는 함수 실행
+       2 2 1    4 4 1
+       2 2 2 -> 4 4 2
+       4 4 4    0 0 4
+  -하: 원래 배열의 행 순서를 뒤집은 후, 상으로 움직이는 함수 실행
+       2 2 1    4 4 4    4 4 4
+       2 2 2 -> 2 2 2 -> 4 4 2
+       4 4 4    2 2 1    0 0 1
+  -좌: 원래 배열의 전치 행렬을 구한 후, 상으로 움직이는 함수 실행
+       2 2 1    2 2 4    4 4 8
+       2 2 2 -> 2 2 4 -> 1 2 4
+       4 4 4    1 2 4    0 0 0
+  -우: 원래 배열의 전치 행렬에서 행 순서를 뒤집은 후, 상으로 움직이는 함수 실행
+       2 2 1    1 2 4    1 4 8
+       2 2 2 -> 2 2 4 -> 4 2 4
+       4 4 4    2 2 4    0 0 0
+
+ - zip(): 두개 이상의 iterable한 객체를 인자로 받아서, 순서대로 하나씩 묶어서 반환한다.
+    ex) zip([1, 2, 3], ['a', 'b', 'c']) -> [1, 'a'], [2, 'b'], [3, 'c']
+    따라서 zip의 인자로 각 행을 넣어주면, 행과 열이 바뀐 Transpose matrix가 나오게 된다.
+"""
+
+def up(board):
+    """
+    위로 움직이는 함수
+    한 열씩 검사하면서 위의 행부터 2개씩 같은 거 있다면 합치기
+    이때 블록 없는 부분은 넘어가고, 블록이 존재했던 값을 저장해서 비교하는 것이 중요!
+    """
+    temp = [[0]*n for _ in range(n)]
+    for c in range(n):
+        idx = 0
+        prev = 0
+        for r in range(n):
+            if not board[r][c]:
+                continue
+            if board[r][c] == prev:
+                temp[idx-1][c] *= 2
+                prev = 0
+            else:
+                temp[idx][c] = board[r][c]
+                prev = board[r][c]
+                idx += 1
+
+    return temp
+
+def backtracking(cnt, board):
+    global ans
+    if cnt == 5:
+        for line in board:
+            ans = max(ans, max(line))
+        return
+
+    # Transpose matrix 구하기 (상 -> 좌)
+    board_t = list(zip(*board))
+
+    # 상
+    backtracking(cnt+1, up(board))
+    # 하
+    backtracking(cnt+1, up(board[::-1]))
+    # 좌
+    backtracking(cnt+1, up(board_t))
+    # 우
+    backtracking(cnt+1, up(board_t[::-1]))
+
+    return
+
+# 입력
+n = int(input())
+board = [list(map(int, input().split())) for _ in range(n)]
+
+ans = 0
+backtracking(0, board)
+
+# 출력
+print(ans)

05월 24일 - 유니온 파인드/과제/16114.py

@@ -0,0 +1,30 @@
+import sys
+input = sys.stdin.readline
+
+"""
+ [화살표 연산자]
+
+ 1. n이 1보다 큰 홀수인 경우 -> ERROR
+ 2. n이 1인데 x가 음수인 경우 -> while문 조건 항상 참 -> INFINITE
+ 3. n이 1인데 x가 양수인 경우 or x가 0보다 작거나 같은 경우 -> while문에 진입 못함 -> 0
+ 4. n이 0인데 x가 양수인 경우 -> while문 조건 항상 참 -> INFINITE
+ 5. 나머지 경우엔 (x-1)를 n//2로 나눈 몫을 출력
+    - 연산했을 때 1 이상이 남을 때까지만 출력을 할 수 있으므로
+"""
+
+def solution(x, n):
+    if n > 1 and n % 2:
+        return "ERROR"
+    if n == 1 and x < 0:
+        return "INFINITE"
+    if n == 1 or x <= 0:
+        return 0
+    if n == 0:
+        return "INFINITE"
+    return (x - 1) // (n // 2)
+
+# 입력
+x, n = map(int, input().split())
+
+# 연산 & 출력
+print(solution(x, n))

05월 24일 - 유니온 파인드/과제/20040.py

@@ -0,0 +1,47 @@
+import sys
+sys.setrecursionlimit(10**6)
+input = sys.stdin.readline
+
+"""
+ [사이클 게임]
+
+ 사이클이 발생한 순간 = 같은 집합에 있는 원소 두 개를 유니온하려 할 때
+ union 함수의 리턴값을 boolean으로 주어 cycle이 생성되는 순간 발견하기
+"""
+
+# find 연산
+def find_parent(x):
+    if parent[x] < 0:
+        return x
+    parent[x] = find_parent(parent[x])
+    return parent[x]
+
+# union 연산
+def union(x, y):
+    px = find_parent(x)
+    py = find_parent(y)
+
+    if px == py:
+        return False
+
+    if parent[px] < parent[py]:
+        parent[px] += parent[py]
+        parent[py] = px
+    else:
+        parent[py] += parent[px]
+        parent[px] = py
+
+    return True
+
+# 입력
+n, m = map(int, input().split())
+parent = [-1]*n     # 초기화
+
+for i in range(m):
+    x, y = map(int, input().split())
+    if not union(x, y):
+        # 사이클이 생성됨
+        print(i+1)
+        break
+else:   # for-else문: for문이 break에 걸리지 않고 정상 종료된 경우에만 else문 실행
+    print(0)

05월 24일 - 유니온 파인드/과제/20303.py

@@ -0,0 +1,59 @@
+import sys
+sys.setrecursionlimit(10**6)
+input = sys.stdin.readline
+
+"""
+ [할로윈의 양아치] - pypy3로 제출
+
+ - weighted union find -> 루트 정점에 아이들의 수(집합 원소 수)와 사탕 개수까지 쌍으로 저장하기
+ - dp(냅색)으로 K명 미만의 아이들에게서 뺏을 수 있는 최대 사탕 수 구하기
+"""
+
+# find 연산
+def find_parent(x):
+    if parent[x][0] < 0:
+        return x
+    parent[x][0] = find_parent(parent[x][0])
+    return parent[x][0]
+
+# union 연산
+def union(x, y):
+    px = find_parent(x)
+    py = find_parent(y)
+
+    if px == py:
+        return
+
+    if parent[px][0] < parent[py][0]:
+        parent[px][0] += parent[py][0]
+        parent[px][1] += parent[py][1]
+        parent[py][0] = px
+    else:
+        parent[py][0] += parent[px][0]
+        parent[py][1] += parent[px][1]
+        parent[px][0] = py
+    return
+
+def knapsack(k):
+    dp = [0] * k    # 1부터 k-1까지
+    count = []      # [아이들의 수, 사탕의 수]
+    for p, c in parent:
+        if p < 0:
+            count.append((-p, c))
+    
+    for child_cnt, candy_cnt in count:
+        for i in range(k-1, child_cnt-1, -1):
+            dp[i] = max(dp[i], dp[i-child_cnt] + candy_cnt)
+
+    return dp[-1]
+
+# 입력
+n, m, k = map(int, input().split())
+parent = [[-1, i] for i in map(int, ("0 "+input()).split())]    #[-아이들의 수, 사탕 개수]
+
+for _ in range(m):
+    a, b = map(int, input().split())
+    union(a, b)
+
+# 연산 & 출력
+print(knapsack(k))

05월 24일 - 유니온 파인드/과제/4195.py

@@ -0,0 +1,63 @@
+import sys
+sys.setrecursionlimit(10**6)
+input = sys.stdin.readline
+
+"""
+ [친구 네트워크]
+
+ 1. weighted union find -> 루트 정점에 친구의 수(집합 원소 수) 저장
+ 2. 친구 네트워크에 몇 명 있는지 구하기 -> 루트 정점의 parent값 접근
+
+ !주의! 정점이 문자열로 들어오므로 map을 활용해 string을 int로 매핑
+"""
+
+# find 연산
+def find_parent(x):
+    if parent[x] < 0:
+        return x
+    parent[x] = find_parent(parent[x])
+    return parent[x]
+
+# union 연산
+def union(x, y):
+    px = find_parent(x)
+    py = find_parent(y)
+
+    if px == py:
+        return
+
+    if parent[px] < parent[py]:
+        parent[px] += parent[py]
+        parent[py] = px
+    else:
+        parent[py] += parent[px]
+        parent[px] = py
+    return
+
+# 입력
+t = int(input())
+
+for _ in range(t):
+    # 입력
+    f = int(input())
+    
+    # 초기화
+    name_to_idx = dict()
+    idx = 0
+    parent = [-1] * (2 * f) # 입력이 모두 다른 이름으로 들어올 경우 -> 최대 2*f개
+
+    for _ in range(f):
+        a, b = input().split()
+
+        if a not in name_to_idx:
+            name_to_idx[a] = idx
+            idx += 1
+        if b not in name_to_idx:
+            name_to_idx[b] = idx
+            idx += 1
+
+        x, y = name_to_idx[a], name_to_idx[b]
+
+        union(x, y)
+
+        print(-parent[find_parent(x)])