Merge pull request #126 from hw0603/hw0603

week17_hw0603

week17/A_32160/hw0603/32160.py

@@ -0,0 +1,20 @@
+from collections import deque
+import sys
+
+N = int(sys.stdin.readline())
+
+q = deque(range(1, N))
+
+result = []
+
+while (len(q) >= 2):
+    n1, n2 = q.pop(), q.pop()
+    result.append(f'{n1} {n2}')
+    newVal = abs(n1 - n2)
+
+    q.appendleft(newVal)
+
+last = q.pop()
+print(N - last)
+print(*result, sep='\n')
+print(last, N)

week17/A_32160/hw0603/README.md

@@ -1,7 +1,13 @@
 # Info
-[Link](https://boj.kr/32160)
+[32160 숫자 놀이](https://boj.kr/32160)
+
 ## 💡 풀이 방법 요약
+관찰 + 그리디
+
+제일 마지막에 `[0, N]` 혹은 `[1, N]` 을 남겨야 한다.
 
 ## 👀 실패 이유
+출력 순서를 거꾸로 출력했다...
 
 ## 🙂 마무리
+메모장 없이는 풀기 어려웠던 문제

week17/B_31997/hw0603/31997.py

@@ -0,0 +1,18 @@
+from itertools import accumulate
+import sys
+
+N, M, T = map(int, sys.stdin.readline().split())
+ioData = {i+1: tuple(map(int, sys.stdin.readline().split())) for i in range(N)}
+result = [0] * (T+1)
+
+for i in range(M):
+    c, d = map(int, sys.stdin.readline().split())  # c랑 d랑 친함
+
+    # 둘이 못 만나면 Skip
+    if (ioData[c][0] > ioData[d][1] or ioData[d][0] > ioData[c][1]):
+        continue
+
+    result[max(ioData[c][0], ioData[d][0])] += 1  # 나중에 입장한 애가 들어와야 쌍 성립
+    result[min(ioData[c][1], ioData[d][1])] -= 1  # 먼저 퇴장한 애가 나가면 쌍 성립 해제
+
+print(*list(accumulate(result))[:-1], sep='\n')

week17/B_31997/hw0603/README.md

@@ -1,7 +1,13 @@
 # Info
-[Link](https://boj.kr/31997)
+[31997 즐거운 회의](https://boj.kr/31997)
+
 ## 💡 풀이 방법 요약
+imos 응용. 사람의 '쌍' 이라는 개념이 추가되었다.
 
-## 👀 실패 이유
+이 '쌍'을 어떻게 고려해 줄 것이냐?
+- 두 사람을 하나의 묶음으로 생각하면 된다.
+- 두 사람의 시간대가 겹치지 않는 경우 없는 사람 취급
+- 두 사람의 시간대가 겹친다면, 두 사람이 처음 만나는 시간에 `+1` 헤어지는 시간에 `-1`
 
 ## 🙂 마무리
+None

week17/C_31932/hw0603/31932.py

@@ -0,0 +1,52 @@
+import heapq
+import sys
+
+N, M = map(int, sys.stdin.readline().split())
+graph = [[] for _ in range(N+1)]
+
+for _ in range(M):
+    u, v, d, t = map(int, sys.stdin.readline().split())
+    graph[u].append((v, d, t))
+    graph[v].append((u, d, t))
+
+# 결정함수: time 에 출발하면 집에 갈 수 있나?
+def dijkstra(time: int) -> bool:
+    dist = [sys.maxsize] * (N+1)
+    dist[1] = time
+    pq = [(time, 1)]  # (time, node): node 에서 time에 출발함
+
+    while (pq):
+        curTime, curNode = heapq.heappop(pq)
+        if (curNode == N):
+            return True  # 집 도착
+
+        # 가지치기: 이전에 구해둔 값보다 큐에서 pop()한게 크면 볼 필요도 x
+        if (curTime > dist[curNode]):
+            continue
+
+        for nextNode, bridgeLength, bridgeTime in graph[curNode]:
+            nextTime = curTime + bridgeLength
+            # 무너지는 다리는 건널 수 없음
+            if (nextTime > bridgeTime):
+                continue
+            # 현재 알려진 시간보다 더 이르게 방문할 수 있으면 갱신
+            if (nextTime < dist[nextNode]):
+                dist[nextNode] = nextTime
+                heapq.heappush(pq, (nextTime, nextNode))
+
+    return False
+
+# T T 'T' F F 찾기
+def binaryJump():
+    low, high = 0, 10**9
+    cur = low - 1
+    step = high
+
+    while (step):
+        while (cur + step <= high and dijkstra(cur+step)):
+            cur += step
+        step //= 2
+
+    return cur
+
+print(binaryJump())

week17/C_31932/hw0603/README.md

@@ -1,7 +1,22 @@
 # Info
-[Link](https://boj.kr/31932)
+[31932 나는 북극곰입니다](https://boj.kr/31932)
+
 ## 💡 풀이 방법 요약
+매개변수 탐색 + 다익스트라 응용
+"`T` 초에 출발하면 집에 갈 수 있나?" 를 계산하는 결정함수를 정의하고, `t`를 매개변수로 하여 `[0, 10^9]` 구간을 이분탐색한다.
+
+결정함수 정의에는 다익스트라 알고리즘을 활용한다.  
+`dist` 배열에 각 노드별 도착할 수 있는 최소 `time`을 유지하면서 다익스트라를 수행하고, 루프 내에서 목적지에 도달할 수 있다면 `True`
+
+`O(logT * O(NlogM)) = O(logT * N * logM) = O(N logM logT)`
 
 ## 👀 실패 이유
+다익스트라에서 중복방문 처리에 해당하는 
+```python
+if (curTime > dist[curNode]):
+    continue
+```
+이 부분을 빼먹었었다. 그런데도 83%까지는 가더라고...
 
 ## 🙂 마무리
+이분탐색이랑 다익스트라 둘 다 오랜만에 풀었더니 쉽지 않았다.