https://programmers.co.kr/learn/courses/30/lessons/81305
\n[본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.]
\n카카오 인턴을 선발하는 코딩 테스트 시험장이 하나의 이진 트리 형태로 연결되어 있습니다. 아래 그림은 12개의 시험장이 연결된 예시입니다.
\n코딩 테스트를 총괄하는 무지는 안정적인 시험을 위해, 시험장에서 오는 트래픽을 k개의 그룹으로 나누어 각 그룹별 서버로 분산시키기로 하였습니다. 시험장 사이를 연결한 간선들 중 k-1개를 끊어서 시험장을 k개의 그룹으로 나눌 계획입니다. 이때, 그룹별 최대 트래픽을 최소화하기 위하여 가장 큰 그룹의 인원을 최소화시켜야 합니다.
위의 그림에서 7번과 6번 시험장을 잇는 간선을 끊고, 9번과 7번 시험장을 잇는 간선을 끊는다면, 전체 시험장은 3개의 그룹으로 나누어집니다.
\n즉, 인원이 가장 많은 그룹은 40명입니다. 다른 어떤 방법으로 시험장을 3개의 그룹으로 나눈다고 해도, 인원이 가장 많은 그룹의 인원이 40명 미만이 되도록 나눌 수는 없습니다.
\n나눌 그룹의 수를 나타내는 정수 k, 각 시험장의 응시자 수를 나타내는 1차원 정수 배열 num, 시험장의 연결 상태를 나타내는 2차원 정수 배열 links가 매개변수로 주어집니다. 인원이 가장 많은 그룹의 인원이 최소화되도록 k개의 그룹으로 나누었을 때, 최소화된 최대 그룹의 인원을 return 하도록 solution 함수를 완성해주세요.
k ≤ 10,000k ≤ num의 길이 ≤ 10,000\nnum[i]에는 i번 시험장의 응시자 수가 담겨있습니다.num의 원소 ≤ 10,000links의 길이 = num의 길이\nlinks의 i번째 행은 i번 노드(시험장)의 [왼쪽 자식 노드 번호, 오른쪽 자식 노드 번호]입니다.\n-1이 담겨있습니다.| k | \nnum | \nlinks | \nresult | \n
|---|---|---|---|
| 3 | \n[12, 30, 1, 8, 8, 6, 20, 7, 5, 10, 4, 1] | \n[[-1, -1], [-1, -1], [-1, -1], [-1, -1], [8, 5], [2, 10], [3, 0], [6, 1], [11, -1], [7, 4], [-1, -1], [-1, -1]] | \n40 | \n
| 1 | \n[6, 9, 7, 5] | \n[[-1, -1], [-1, -1], [-1, 0], [2, 1]] | \n27 | \n
| 2 | \n[6, 9, 7, 5] | \n[[-1, -1], [-1, -1], [-1, 0], [2, 1]] | \n14 | \n
| 4 | \n[6, 9, 7, 5] | \n[[-1, -1], [-1, -1], [-1, 0], [2, 1]] | \n9 | \n
DFS, Parametric Search
\n# Parametric Search\n while start < end:\n mid = (start + end) // 2\n count = 0\n dfs(root, mid, num)\n count += 1\n if count <= k:\n end = mid\n else:\n start = mid + 1최소화된 최대 그룹의 인원을 구하는 최적화 문제를 각 그룹을 x명으로 제한할 때 k개 이하의 그룹 수가 되는지 판단하는 결정 문제로 바꿔서 해결def dfs(node, limit, num):\n global count\n left_value, right_value = 0, 0\n if left[node] != -1: \n left_value = dfs(left[node], limit, num) # 왼쪽 자식 노드에서 오는 값\n if right[node] != -1:\n right_value = dfs(right[node], limit, num) # 오른쪽 자식 노드에서 오는 값\n # 나눌 필요 없는 경우\n if num[node] + left_value + right_value <= limit:\n return num[node] + left_value + right_value\n # 자식 노드 중 하나만 나누면 되는 경우\n if num[node] + min(left_value, right_value) <= limit:\n count += 1\n return num[node] + min(left_value, right_value)\n # 자식 노드 둘 다 나눠야 하는 경우\n count += 2\n return num[node]limit를 벗어나지 않게 비교하면서 상위 노드로 올려주고, limit를 벗어나면 그룹을 나누어준다.\nlimit를 넘지 않아서 자식 노드와 그룹 나눌 필요 없는 경우limit를 넘지 않아서 하나만 나누면 되는 경우from collections import defaultdict\nimport sys\nsys.setrecursionlimit(10**6)\n\nleft, right, parent = defaultdict(int), defaultdict(int), defaultdict(lambda: -1)\ncount = 0\n\ndef dfs(node, limit, num):\n global count\n left_value, right_value = 0, 0\n if left[node] != -1: \n left_value = dfs(left[node], limit, num) # 왼쪽 자식 노드에서 오는 값\n if right[node] != -1:\n right_value = dfs(right[node], limit, num) # 오른쪽 자식 노드에서 오는 값\n # 나눌 필요 없는 경우\n if num[node] + left_value + right_value <= limit:\n return num[node] + left_value + right_value\n # 자식 노드 중 하나만 나누면 되는 경우\n if num[node] + min(left_value, right_value) <= limit:\n count += 1\n return num[node] + min(left_value, right_value)\n # 자식 노드 둘 다 나눠야 하는 경우\n count += 2\n return num[node]\n \ndef solution(k, num, links):\n global count\n root, start, end = 0, max(num), 10 ** 8\n # 트리 정보 입력\n for i in range(len(num)):\n left[i], right[i] = links[i]\n if left[i] != -1: parent[left[i]] = i\n if right[i] != -1: parent[right[i]] = i\n # root 값 찾기\n for i in range(len(num)):\n if parent[i] == -1: \n root = i\n break\n # 이분 탐색\n while start < end:\n mid = (start + end) // 2\n count = 0\n dfs(root, mid, num)\n count += 1\n if count <= k:\n end = mid\n else:\n start = mid + 1\n return startDFS로 해야 되나,,?? 라는 생각만 들고 감이 안잡혀서 다른 사람들 풀이 보고 이해했다..
\n난이도가 그만큼 어려워서인지 풀이도 많지 않았고, 봐도 이해하는데 오래걸렸다.
\nParametric Search 라는 알고리즘은 처음 알게 되었고, 이해는 했으니 이제 많이 풀어봐야겠다ㅜ
https://programmers.co.kr/learn/courses/30/lessons/81304
\n신규 게임 ‘카카오 미로 탈출’이 출시되어, 라이언이 베타테스터로 참가했습니다.
\n위 예시 그림은 카카오 미로 탈출의 초기 상태를 나타냅니다. 1번부터 3번까지 번호가 붙어있는 3개의 방이 있고, 방과 방 사이를 연결하는 길에는 이동하는데 걸리는 시간이 표시되어 있습니다. 길은 화살표가 가리키는 방향으로만 이동할 수 있습니다. 미로에는 함정이 존재하며, 함정으로 이동하면, 이동한 함정과 연결된 모든 화살표의 방향이 바뀝니다.
\n출발지점인 1번 방에서 탈출이 가능한 3번 방까지 이동해야 합니다. 탈출하는데 걸리는 최소 시간을 구하려고 합니다.
n개일 때, 방 번호는 1부터 n까지 사용됩니다.2번 방은 함정입니다.\n1번 방에서 2번 방으로 이동하는 순간 1에서 2로 이동할 수 있던 길은 2에서 1로 이동할 수 있는 길로 바뀌고, 3에서 2로 이동할 수 있던 길은 2에서 3으로 이동할 수 있는 길로 바뀝니다.방의 개수를 나타내는 정수 n, 출발 방의 번호 start, 도착 방의 번호 end, 통로와 이동시간을 나타내는 2차원 정수 배열 roads, 함정 방의 번호를 담은 정수 배열 traps이 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최단 시간을 return 하도록 solution 함수를 완성해주세요.
n ≤ 1,000start ≤ nend ≤ nroads의 행 길이 ≤ 3,000roads의 행은 [P, Q, S]로 이루어져 있습니다.\nP에서 Q로 갈 수 있는 길이 있으며, 길을 따라 이동하는데 S만큼 시간이 걸립니다.P ≤ nQ ≤ nP ≠ QS ≤ 3,000traps의 길이 ≤ 10\ntraps의 원소 ≤ n| n | \nstart | \nend | \nroads | \ntraps | \nresult | \n
|---|---|---|---|---|---|
| 3 | \n1 | \n3 | \n[[1, 2, 2], [3, 2, 3]] | \n[2] | \n5 | \n
| 4 | \n1 | \n4 | \n[[1, 2, 1], [3, 2, 1], [2, 4, 1]] | \n[2, 3] | \n4 | \n
Dijkstra, BitMask
\ngraph = defaultdict(list)\n# visited : 활성화 된 함정 노드에 따라 방문했던 노드 표시\n# visited[node][활성화 된 함정 상태] (활성화 된 함정 상태는 비트마스크로 표시)\nvisited = [[INF for _ in range(2**len(traps))]for _ in range(n+1)]\ntraps_dict = {n: i for i, n in enumerate(traps)} # 함정 노드: traps 리스트 상 index\n# 그래프 정보 입력\nfor a, b, v in roads:\n graph[a].append([b, v, False]) # False : 정방향\n graph[b].append([a, v, True]) # True : 역방향visited : 활성화 된 함정 노드에 따라 방문했던 노드 표시visited[node][활성화 된 함정 상태] (활성화 된 함정 상태는 비트마스크로 표시)traps_dict : (함정노드: traps 리스트 상 index) 형태로 dictionary 생성defaultdict로 생성한 graph에 정보 입력# 다익스트라 알고리즘\n h = []\n heapq.heappush(h, (0, start, 0))\n visited[start][0] = 0\n while h:\n cost, node, state = heapq.heappop(h)\n # end 노드 도착\n if node == end:\n answer = min(answer, cost)\n continue\n # 이미 방문한 값보다 크면 방문 X\n if cost > visited[node][state]:\n continue\n for next_node, next_cost, direction in graph[node]:\n # 함정 노드면 비트마스킹\n cur_trap, next_trap = False, False\n if node in traps_dict:\n cur_trap = bool(state & (1 << traps_dict[node]))\n if next_node in traps_dict:\n next_trap = bool(state & (1 << traps_dict[next_node]))\n if direction != (cur_trap ^ next_trap): # cur_trap, next_trap 상태가 같으면 정방향, 다르면 역방향\n continue\n # 다음 노드가 함정 노드인지에 따라 상태 변경\n next_state = state\n if next_node in traps_dict:\n next_state = state ^ (1 << traps_dict[next_node])\n # 다음 cost 계산하고, 다음 상태의 cost가 이미 방문했고 더 작으면 방문 X\n next_cost = cost + next_cost\n if next_cost >= visited[next_node][next_state]:\n continue\n visited[next_node][next_state] = next_cost\n heapq.heappush(h, (next_cost, next_node, next_state))\n return answerend 노드 도착answer에 answer와 cost 중 최솟값 저장하고 heap에 값이 남아있을 수도 있으니 continue 해서 계속 진행& 비트 연산하여 저장cur_trap, next_trap의 값이 같으면 정방향, 다르면 역방향import heapq, sys\nfrom collections import defaultdict\n\ndef solution(n, start, end, roads, traps):\n INF = sys.maxsize\n answer = INF\n graph = defaultdict(list)\n # visited : 활성화 된 함정 노드에 따라 방문했던 노드 표시\n # visited[node][활성화 된 함정 상태] (활성화 된 함정 상태는 비트마스크로 표시)\n visited = [[INF for _ in range(2**len(traps))]for _ in range(n+1)]\n traps_dict = {n: i for i, n in enumerate(traps)} # 함정 노드: traps 리스트 상 index\n # 그래프 정보 입력\n for a, b, v in roads:\n graph[a].append([b, v, False]) # False : 정방향\n graph[b].append([a, v, True]) # True : 역방향\n # 다익스트라 알고리즘\n h = []\n heapq.heappush(h, (0, start, 0))\n visited[start][0] = 0\n while h:\n cost, node, state = heapq.heappop(h)\n # end 노드 도착\n if node == end:\n answer = min(answer, cost)\n continue\n # 이미 방문한 값보다 크면 방문 X\n if cost > visited[node][state]:\n continue\n for next_node, next_cost, direction in graph[node]:\n # 함정 노드면 비트마스킹\n cur_trap, next_trap = False, False\n if node in traps_dict:\n cur_trap = bool(state & (1 << traps_dict[node]))\n if next_node in traps_dict:\n next_trap = bool(state & (1 << traps_dict[next_node]))\n if direction != (cur_trap ^ next_trap): # cur_trap, next_trap 상태가 같으면 정방향, 다르면 역방향\n continue\n # 다음 노드가 함정 노드인지에 따라 상태 변경\n next_state = state\n if next_node in traps_dict:\n next_state = state ^ (1 << traps_dict[next_node])\n # 다음 cost 계산하고, 다음 상태의 cost가 이미 방문했고 더 작으면 방문 X\n next_cost = cost + next_cost\n if next_cost >= visited[next_node][next_state]:\n continue\n visited[next_node][next_state] = next_cost\n heapq.heappush(h, (next_cost, next_node, next_state))\n return answer다익스트라로 풀어야하고, 방향을 다르게 해서 구현해야 한다는 점까지는 이해했지만 쉽게 구현할 수 없었다.
\n시간을 많이 투자했는데도 해결이 안돼서 다른 풀이를 참고했고, 비트마스크를 사용해서 푸는 방법을 찾을 수 있었다.
\n풀이를 보고도 이해해서 다시 코드를 짜는데 시간이 많이 걸렸고, 비트마스크 방식에 대해 더 자세히 알아봐야겠다..
\n카카오 문제들이 계속해서 4번부터 어려웠지만 이번 문제는 진짜 어려웠고 이해하는데 너무 오래걸렸다..
https://programmers.co.kr/learn/courses/30/lessons/64064
\n개발팀 내에서 이벤트 개발을 담당하고 있는 “무지”는 최근 진행된 카카오이모티콘 이벤트에 비정상적인 방법으로 당첨을 시도한 응모자들을 발견하였습니다. 이런 응모자들을 따로 모아 불량 사용자라는 이름으로 목록을 만들어서 당첨 처리 시 제외하도록 이벤트 당첨자 담당자인 “프로도” 에게 전달하려고 합니다. 이 때 개인정보 보호을 위해 사용자 아이디 중 일부 문자를 ’’ 문자로 가려서 전달했습니다. 가리고자 하는 문자 하나에 ’’ 문자 하나를 사용하였고 아이디 당 최소 하나 이상의 ’*’ 문자를 사용하였습니다.
\n“무지”와 “프로도”는 불량 사용자 목록에 매핑된 응모자 아이디를 제재 아이디 라고 부르기로 하였습니다.
예를 들어, 이벤트에 응모한 전체 사용자 아이디 목록이 다음과 같다면
\n| 응모자 아이디 | \n
|---|
| frodo | \n
| fradi | \n
| crodo | \n
| abc123 | \n
| frodoc | \n
다음과 같이 불량 사용자 아이디 목록이 전달된 경우,
\n| 불량 사용자 | \n
|---|
| frd | \n
| abc1** | \n
불량 사용자에 매핑되어 당첨에서 제외되어야 야 할 제재 아이디 목록은 다음과 같이 두 가지 경우가 있을 수 있습니다.
\n| 제재 아이디 | \n
|---|
| frodo | \n
| abc123 | \n
| 제재 아이디 | \n
|---|
| fradi | \n
| abc123 | \n
이벤트 응모자 아이디 목록이 담긴 배열 user_id와 불량 사용자 아이디 목록이 담긴 배열 banned_id가 매개변수로 주어질 때, 당첨에서 제외되어야 할 제재 아이디 목록은 몇가지 경우의 수가 가능한 지 return 하도록 solution 함수를 완성해주세요.
\n| user_id | \nbanned_id | \nresult | \n
|---|---|---|
| [“frodo”, “fradi”, “crodo”, “abc123”, “frodoc”] | \n[\"fr*d*\", \"abc1**\"] | \n2 | \n
| [“frodo”, “fradi”, “crodo”, “abc123”, “frodoc”] | \n[\"*rodo\", \"*rodo\", \"******\"] | \n2 | \n
| [“frodo”, “fradi”, “crodo”, “abc123”, “frodoc”] | \n[\"fr*d*\", \"*rodo\", \"******\", \"******\"] | \n3 | \n
문자열, 순열
\n order_list = permutations(user_id, len(banned_id)) # 순열 생성\n for order in order_list:\n check = True\n for i, id in enumerate(banned_id):\n # 정규 표현식 사용 (^: 시작 부분 매치 확인, $: 끝 부분 매치 확인)\n pattern = re.compile(f\"^{id.replace('*', '.')}$\") # '*'는 '.'으로 치환\n if not pattern.match(order[i]): check = False\n # 전부 다 일치하는 경우\n if check:\n order = sorted(list(order)) # 중복 제거를 위해 우선 정렬\n result.append(tuple(order)) # set 처리하기 위해 tuple로 변환 후 append\n return len(set(result)) # set 이용해서 중복 제거user_id 배열에서 len(banned_id)개의 원소를 뽑는 순열을 만든다.f 포매팅과 replace를 이용하여 * 문자를 . 으로 변환하고,^ 메타문자와 $ 메타문자를 사용하여 시작 부분과 끝 부분 모두 매칭하는지 확인할 정규 표현식 패턴 생성sorted를 사용해서 우선 정렬하고,result 리스트에 append 해준다.import re\nfrom itertools import permutations\ndef solution(user_id, banned_id):\n result = []\n order_list = permutations(user_id, len(banned_id)) # 순열 생성\n for order in order_list:\n check = True\n for i, id in enumerate(banned_id):\n # 정규 표현식 사용 (^: 시작 부분 매치 확인, $: 끝 부분 매치 확인)\n pattern = re.compile(f\"^{id.replace('*', '.')}$\") # '*'는 '.'으로 치환\n if not pattern.match(order[i]): check = False\n # 전부 다 일치하는 경우\n if check:\n order = sorted(list(order)) # 중복 제거를 위해 우선 정렬\n result.append(tuple(order)) # set 처리하기 위해 tuple로 변환 후 append\n return len(set(result)) # set 이용해서 중복 제거처음 보자마자 순열을 생성해서 경우의 수를 비교해야겠다고 생각했고, 정규 표현식을 공부한 후 정규 표현식 활용해서 풀었다.
\n당연히 순열 문제로 생각했는데 거의 다 DFS나 비트마스크로 풀었다는게 신기,,
\n중복 제거를 위해 list로 변환해 정렬하고, tuple로 변환해서 append하고, 다시 set 처리하는 과정에서 실행 시간이 오래 걸린 것 같다…