Merge pull request #137 from hyg4779/main

0906 스터디 문제풀이

Author: ChiwooKim

programmers/Lv2_다리를_지나는_트럭/s1_hyg4779.py

@@ -0,0 +1,41 @@
+def solution(n, k, arr):
+    # 다리길이, 견딜 수 있는 무게, 트럭무게배열
+    def bridge():
+        nonlocal state, n, w
+        tmp = False
+
+        for truck in state:
+            truck[1] += 1
+            if truck[1] == n:
+                tmp = True
+        else:
+            if tmp:
+                val, _ = state.pop(0)
+                w -= val
+        return
+
+
+    answer = 0
+    state, w = [], 0
+
+    idx = 0
+    while idx < len(arr):
+        bridge()
+        now = arr[idx]
+        flag = False
+
+        if len(state) < n and w+now <= k:
+            flag = True
+
+        if flag:
+            w += now
+            state.append([now, 0])
+            idx += 1
+
+        answer += 1
+
+    while state:
+        bridge()
+        answer += 1
+
+    return answer

programmers/Lv2_두_큐_합_같게_만들기/s1_hyg4779.py

@@ -0,0 +1,39 @@
+def solution(queue1, queue2):
+
+    n, m = sum(queue1), sum(queue2)
+
+    l = len(queue1)
+    answer = l
+
+    dp = [[[0, 0] for _ in range(l*2)] for _ in range(l*2)]
+    dp[0][0] = [n, m]
+
+
+    def dfs(a, b):
+        nonlocal answer
+        if dp[a][b][0] == dp[a][b][1]:
+            answer = min(answer, a+b)
+            return a+b
+
+        if a+1 < l*2:
+            if a//l:
+                dp[a+1][b] = [dp[a][b][0]-queue2[a%l], dp[a][b][1]+queue2[a%l]]
+            else:
+                dp[a+1][b] = [dp[a][b][0]-queue1[a%l], dp[a][b][1]+queue1[a%l]]
+            dfs(a+1, b)
+
+        if b+1 < l*2:
+            if b//l:
+                dp[a][b+1] = [dp[a][b][0]+queue1[b%l], dp[a][b][1]-queue1[b%l]]
+            else:
+                dp[a][b+1] = [dp[a][b][0]+queue2[b%l], dp[a][b][1]-queue2[b%l]]
+            dfs(a, b+1)
+
+    dfs(0, 0)
+
+    return -1 if answer == l else answer
+
+
+print(solution([3, 2, 7, 2], [4, 6, 5, 1]))
+print(solution([1, 2, 1, 2], [1, 10, 1, 2]))
+print(solution([1, 1], [1, 5]))

programmers/Lv2_위장/s1_hyg4779.py

@@ -0,0 +1,15 @@
+def solution(clothes):
+
+    answer = 1
+
+    hash_map = {}
+    # 종류 별 몇벌이 있는지 더한다
+    for prod, kind in clothes:
+        hash_map[kind] = hash_map.get(kind, 0)+1
+
+    # 해당 옷을 입는 모든 경우를 곱한다(+1 하는건 안입는 경우)
+    for kind in hash_map:
+        answer *= (hash_map[kind]+1)
+
+    # 전체를 안 입는 경우를 뺸다
+    return answer-1

programmers/Lv3_등산코스_정하기/s1_hyg4779.py

@@ -0,0 +1,80 @@
+from collections import deque
+
+def solution(n, paths, gates, summits):
+
+    graph = [[] for _ in range(n+1)]
+    for a, b, c in paths:
+        graph[a].append([b, c])
+        graph[b].append([a, c])
+
+
+    dist = [10000001 for _ in range(n+1)]
+    for gate in gates:
+        dist[gate] = 0
+
+    Q = deque(gates)
+    while Q:
+        now = Q.popleft()
+        if now in summits: continue
+        for node, cost in graph[now]:
+            cost = max(dist[now], cost)
+            if dist[node] > cost:
+                Q.append(node)
+                dist[node] = cost
+
+
+    min_dis = float('inf')
+    min_summit = -1
+
+    for summit in summits:
+        if min_dis > dist[summit]:
+            min_dis = dist[summit]
+            min_summit = summit
+        elif min_dis == dist[summit] and min_summit > summit:
+            min_summit = summit
+
+    return [min_summit, min_dis]
+
+'''
+import collections
+
+def bfs(n, graph, gates, summits, distance):
+    que = collections.deque(gates)
+    while que:
+        cur_loc = que.popleft()
+        if cur_loc in summits: continue
+        for next_loc, way in graph[cur_loc]:
+            if distance[next_loc] > max(distance[cur_loc], way):
+                que.append(next_loc)
+                distance[next_loc] = max(distance[cur_loc], way)
+                
+    return distance
+        
+def solution(n, paths, gates, summits):
+    answer = []
+    graph = [[] for _ in range(n+1)]
+    for a, b, c in paths:
+        graph[a].append([b, c])
+        graph[b].append([a, c])
+        
+    summits_dict = {}
+    min_dis = float('inf')
+    min_summit = -1
+    for summit in summits:
+        summits_dict[summit] = 1
+    
+    distance = [10000001 for _ in range(n+1)]
+    for gate in gates:
+        distance[gate] = 0
+        
+    distance = bfs(n, graph, gates, summits_dict, distance)
+        
+    for summit in summits:
+        if min_dis > distance[summit]:
+            min_dis = distance[summit]
+            min_summit = summit
+        elif min_dis == distance[summit] and min_summit > summit:
+            min_summit = summit
+                
+    return [min_summit, min_dis]
+'''

programmers/Lv3_이중우선순위큐/s1_hyg4779.py

@@ -0,0 +1,26 @@
+def solution(operations):
+
+    Q = list()
+
+    def q_sort(arr):
+        if len(arr) <= 1:
+            return arr
+        pivot = arr[0]
+        l = [a for a in arr[1:] if a < pivot]
+        r = [b for b in arr[1:] if b >= pivot]
+        return q_sort(l) + [pivot] + q_sort(r)
+
+    for comm in operations:
+        if comm[0] == 'I':
+            Q.append(int(comm.split(' ')[1]))
+            new = q_sort(Q)
+            Q = new
+
+        else:
+            if Q:
+                if len(comm) > 3:
+                    Q.pop(0)
+                else:
+                    Q.pop()
+
+    return [Q[-1], Q[0]] if Q else [0, 0]

programmers/Lv3_코딩_테스트_공부/s1_hyg4779.py

@@ -0,0 +1,41 @@
+import sys
+sys.setrecursionlimit(10000)
+
+
+def solution(alp, cop, problems):
+    answer = 10000
+    n = len(problems)
+
+    max_al, max_cl = max(problems, key=lambda x:x[0])[0], max(problems, key=lambda x:x[1])[1]
+
+    dp = [[float('inf')]*181 for _ in range(181)]
+    dp[alp][cop] = 0
+
+    def dfs(a, c, t):
+        nonlocal answer
+
+        if a >= max_al and c >= max_cl:
+            answer = min(t, answer)
+            return
+
+        if dp[a][c] < t:
+            return
+
+        dp[a][c] = t
+
+        for i in range(n):
+            now = problems[i]
+            if a < now[0]:
+                dfs(now[0], c, t + now[0]-a)
+            if c < now[1]:
+                dfs(a, now[1], t + now[1]-c)
+            if a >= now[0] and c >= now[1]:
+                dfs(a+now[2], c+now[3], t+now[4])
+
+
+    dfs(alp, cop, 0)
+
+    return answer
+
+print(solution(10, 10, [[10, 15, 2, 1, 2], [20, 20, 3, 3, 4]]))
+print(solution(0, 0, [[0, 0, 2, 1, 2], [4, 5, 3, 1, 2], [4, 11, 4, 0, 2], [10, 4, 0, 4, 2]]))