백준 23290

baekjoon/1197.py

@@ -0,0 +1,41 @@
+V, E = map(int, input().split())
+cost = 0
+parent = [i for i in range(V+1)]
+rank = [0 for i in range(V+1)]
+edges = []
+for e in range(E):
+    edges.append(tuple(map(int, input().split())))
+edges.sort(key=lambda x: x[2])
+
+
+def find(u):
+    p = parent[u]
+    if p == u:
+        return u
+    return find(p)
+
+
+def union(u, v):
+    p1 = find(u)
+    p2 = find(v)
+    r1 = rank[p1]
+    r2 = rank[p2]
+    if r1 > r2:
+        parent[p2] = p1
+    elif r1 < r2:
+        parent[p1] = p2
+    else:
+        parent[p1] = p2
+        rank[p2] += 1
+    return
+
+
+l = 1
+for a, b, w in edges:
+    if find(a) != find(b):
+        union(a, b)
+        cost += w
+        l += 1
+        if l == V:
+            break
+print(cost)

baekjoon/16235.py

@@ -1,38 +1,52 @@
 N, M, K = map(int, input().split())
 A = []
-namu = [[[] for _ in range(N)] for i in range(N)]
+namu = [[{} for _ in range(N)] for i in range(N)]
 land = [[5] * N for _ in range(N)]
 for i in range(N):
     A.append(list(map(int, input().split())))
 for i in range(M):
     x, y, z = map(int, input().split())
-    namu[x - 1][y - 1].append(z)
+    if z in namu[x - 1][y - 1]:
+        namu[x - 1][y - 1][z] += 1
+    else:
+        namu[x - 1][y - 1][z] = 1
 mv = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
+
 for _ in range(K):
     # spring
     for i in range(N):
         for j in range(N):
-            namu[i][j].sort()  # 어린 순
-            for k in range(len(namu[i][j])):
-                if namu[i][j][k] <= land[i][j]:
-                    land[i][j] -= namu[i][j][k]
-                    namu[i][j][k] += 1
+            tmp = {}
+            die = 0
+            for age, cnt in sorted(namu[i][j].items()):
+                l = (land[i][j] // age)
+                if cnt <= l:
+                    land[i][j] -= age * cnt
+                    tmp[age + 1] = cnt
+                elif 1 <= l:
+                    land[i][j] -= l * age
+                    tmp[age + 1] = l
+                    die += (age // 2) * (cnt - l)
                 else:
-                    for l in range(k, len(namu[i][j])):  # summer
-                        land[i][j] += namu[i][j].pop() // 2
-                    break
+                    die += (age // 2) * cnt
+            namu[i][j] = tmp
+            land[i][j] += die
     for i in range(N):  # fall
         for j in range(N):
-            for k in range(len(namu[i][j])):
-                if namu[i][j][k] % 5 == 0:
+            for age, cnt in namu[i][j].items():
+                if age % 5 == 0:
                     for x, y in mv:
-                        if 0 <= i + x < N and 0 <= j + y < N:
-                            namu[i + x][j + y].append(1)
-    for i in range(N):  # winter
-        for j in range(N):
-            land[i][j] += A[i][j]
+                        ii = i + x
+                        jj = j + y
+                        if 0 <= ii < N and 0 <= jj < N:
+                            if namu[ii][jj].get(1):
+                                namu[ii][jj][1] += cnt
+                            else:
+                                namu[ii][jj][1] = cnt
+            land[i][j] += A[i][j]  # winter
 answer = 0
 for i in range(N):
     for j in range(N):
-        answer += len(namu[i][j])
+        for k in namu[i][j].values():
+            answer += k
 print(answer)

baekjoon/16236.py

@@ -0,0 +1,58 @@
+from collections import deque
+from sys import stdin
+N = int(stdin.readline())
+fishes = []
+for i in range(N):
+    col = list(map(int, stdin.readline().split()))
+    for j, fish in enumerate(col):
+        if fish == 9:
+            baby = [i, j]
+            col[j] = 0
+    fishes.append(col)
+mv = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+bsize = 2
+bcnt = 0
+
+
+def bfs():
+    visited = [[False] * N for _ in range(N)]
+    q = deque([(0, baby[0], baby[1])])
+    maxp = 10000
+    candi = []
+    while q:
+        p, x, y = q.popleft()
+        if visited[x][y]:
+            continue
+        if maxp < p:
+            break
+        elif 0 < fishes[x][y] < bsize:
+                maxp = p
+                candi.append((x, y, p))
+        visited[x][y] = True
+        for i, j in mv:
+            xx = x + i
+            yy = y + j
+            if 0 <= xx < N and 0 <= yy < N and fishes[xx][yy] <= bsize and not visited[xx][yy]:
+                q.append((p+1, xx, yy))
+    if not candi:
+        return False
+    candi.sort()
+    return candi[0]
+
+
+answer = 0
+while True:
+    ret = bfs()
+    if not ret:
+        break
+    x, y, p = ret
+    answer += p
+    baby = [x, y]
+    fishes[x][y] = 0
+    bcnt += 1
+    if bcnt == bsize:
+        bsize += 1
+        bcnt = 0
+
+
+print(answer)

baekjoon/17140.py

@@ -0,0 +1,42 @@
+from collections import defaultdict
+R, C, K = map(int, input().split())
+R, C = R - 1, C - 1
+A = [list(map(int, input().split())) for _ in range(3)]
+
+def oper(A):
+    l = 0
+    for i in range(len(A)):
+        cnt_dict = defaultdict(int)
+        for a in A[i]:
+            if a != 0:
+                cnt_dict[a] += 1
+        cnt_pairs = [(c, n) for n, c in cnt_dict.items()]
+        cnt_pairs.sort()
+        A[i] = []
+        for c, n in cnt_pairs:
+            A[i].append(n)
+            A[i].append(c)
+            if len(A[i]) > 100:
+                break
+        l = max(l, len(A[i]))
+    for row in A:
+        for j in range(max(0, l-len(row))):
+            row.append(0)
+    return
+
+
+for i in range(100):
+    if 0 <= R < len(A) and 0 <= C < len(A[0]) and A[R][C] == K:
+        print(i)
+        break
+    if len(A) >= len(A[0]):
+        oper(A)
+    else:
+        A = list(map(list, zip(*A)))
+        oper(A)
+        A = list(map(list, zip(*A)))
+else:
+    if 0 <= R < len(A) and 0 <= C < len(A[0]) and A[R][C] == K:
+        print(100)
+    else:
+        print(-1)

baekjoon/17143.py

@@ -0,0 +1,49 @@
+R, C, M = map(int, input().split())
+sharks = [[False for i in range(C)] for _ in range(R)]
+for i in range(M):
+    r, c, s, d, z = map(int, input().split())
+    sharks[r - 1][c - 1] = (s, d - 1, z)
+ans = 0
+
+
+def cal_mv(sharks):
+    new_pos = [[False for i in range(C)] for _ in range(R)]
+    for i in range(R):
+        for j in range(C):
+            if not sharks[i][j]:
+                continue
+            s, d, z = sharks[i][j]
+            if d == 0 or d == 1:
+                if d == 0:
+                    p = -s + i
+                else:
+                    p = s + i
+                d = (p // (R - 1) + d) % 2
+                p %= (2 * (R - 1))
+                if p > (R - 1):
+                    p = 2 * (R - 1) - p
+                if not new_pos[p][j] or new_pos[p][j][2] < z:
+                    new_pos[p][j] = (s, d, z)
+            else:
+                if d == 3:
+                    p = -s + j
+                else:
+                    p = s + j
+                if (p // (C - 1)) % 2:
+                    d = (d - 1) % 2 + 2
+                p %= (2 * (C - 1))
+                if p > (C - 1):
+                    p = 2 * (C - 1) - p
+                if not new_pos[i][p] or new_pos[i][p][2] < z:
+                    new_pos[i][p] = (s, d, z)
+    return new_pos
+
+
+for c in range(C):
+    for i in range(R):
+        if sharks[i][c]:
+            ans += sharks[i][c][2]
+            sharks[i][c] = False
+            break
+    sharks = cal_mv(sharks)
+print(ans)

baekjoon/17779.py

@@ -0,0 +1,37 @@
+N = int(input())
+A = [list(map(int, input().split())) for _ in range(N)]
+total = 0
+for i in range(N):
+    total += sum(A[i])
+
+def divide(x, y, d1, d2):
+    popul = [0, 0, 0, 0]
+    lx, ly = x+d1, y-d1
+    rx, ry = x+d2, y+d2
+    bx, by = x+d1+d2, y-d1+d2
+    for i in range(x):
+        popul[0] += sum(A[i][:y+1])
+        popul[1] += sum(A[i][y+1:])
+    for i in range(x, lx):
+        popul[0] += sum(A[i][:y-i+x])
+    for i in range(x, rx+1):
+        popul[1] += sum(A[i][y+1+i-x:])
+    for i in range(lx, bx+1):
+        popul[2] += sum(A[i][:ly-lx+i])
+    for i in range(rx+1, bx+1):
+        popul[3] += sum(A[i][ry+rx+1-i:])
+    for i in range(bx+1, N):
+        popul[2] += sum(A[i][:by])
+        popul[3] += sum(A[i][by:])
+    popul.append(total-sum(popul))
+    return max(popul) - min(popul)
+
+
+ret = float('inf')
+for x in range(N - 2):
+    for y in range(1, N - 1):
+        for d1 in range(1, y):
+            for d2 in range(1, min(N - y, N-(x+d1))):
+                ret = min(ret, divide(x, y, d1, d2))
+
+print(ret)

baekjoon/17822.py

@@ -0,0 +1,57 @@
+from collections import deque
+
+
+N, M, T = map(int, input().split())
+circle = [list(map(int, input().split())) for _ in range(N)]
+multiple = {i+1: [] for i in range(N)}
+mv = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+for i in range(1, N+1):
+    for j in range(1, N//i + 1):
+        multiple[i].append(i*j-1)
+
+
+def swap(n, d, k):
+    res = 0
+    if d == 0:  # 0 clockwise
+        k = M - k
+    for i in multiple[n]:  # 숫자를 swap
+        circle[i] = circle[i][k:] + circle[i][:k]
+    candi = set()
+    for i in range(N):
+        for j in range(M):
+            if circle[i][j] > 0 and circle[i][j] == circle[i][j-1]:
+                candi.add((i, j))
+                candi.add((i, j-1))
+    for i in range(N-1):
+        for j in range(M):
+            if circle[i][j] > 0 and circle[i][j] == circle[i+1][j]:
+                candi.add((i, j))
+                candi.add((i+1, j))
+    for i, j in candi:
+        circle[i][j] = 0
+    if not candi:
+        nums = []
+        for i in range(N):
+            for j in range(M):
+                if circle[i][j] > 0:
+                    nums.append(circle[i][j])
+        mean = sum(nums) / len(nums)
+        for i in range(N):
+            for j in range(M):
+                if circle[i][j] > mean:
+                    circle[i][j] -= 1
+                elif 0 < circle[i][j] < mean:
+                    circle[i][j] += 1
+    for i in range(N):  # 원판의 숫자를 sum
+        res += sum(circle[i])
+    return res
+
+
+for i in range(T):
+    n, d, k = map(int, input().split())
+    res = swap(n, d, k)
+    if not res:
+        print(res)
+        break
+else:
+    print(res)