손가락놀이터

문제후기

1. 우선순위 큐를 활용한 문제로 Python은 우선순위 큐를 heap을 활용해서 해결합니다.
2. 절대값이 기준이고 그 다음 기준이 숫자이므로 (절대값, 숫자) 형식으로 heap에 push합니다.
3. 0이 나올 경우 heap에서 pop을 해서 출력합니다.

문제링크

from sys import stdin
import heapq

N = int(stdin.readline())
# 우선순위 큐
heap = []

for n in range(N):
    num = int(stdin.readline())
    if num != 0:
        # 0이 아닌 경우 우선순위 큐에 (절대값, 숫자) 삽입
        heapq.heappush(heap,(abs(num), num))
    # 0인경우
    else:
        # 큐가 비어있으면 0 출력
        if len(heap) == 0:
            print(0)
        else:
            # 큐에 값이 있으면 pop
            print(heapq.heappop(heap)[1])

문제후기

1. 해당 문제는 1부터 시작해서 g와 h를 거친 이후 최종 목적지로 가는 것을 확인하는 문제로 다익스트라를 활용해야겠다고 생각을 했습니다. 시간초과를 피하기 위해서 우선순위 큐도 적용했습니다.
2. 최종 목적지 후보로 도착하기 전에 g와 h 사이의 직선을 거쳐야하므로 1 -> g -> h -> 최종 or 1 -> h -> g -> 최종입니다.
3. 처음 문제를 풀고 제출을 했을때 틀렸는데 문제에서 2번에서 가는 것이 1-> 최종보다 작야한다는 것을 파악하지 못했습니다.

문제링크

from sys import stdin
import heapq

# 방문여부 확인용 초기값
INF = 1e9

# 다익스트라 알고리즘
def dijkstra(start, last):
    # 방문여부
    dp = [INF] * (n+1)
    # 시작 값 0부터 시작
    dp[start] = 0
    heap = []
    # 힙에 (거리값, 정점) push, 우선순위 큐
    heapq.heappush(heap, (dp[start], start))

    # 힙이 있을때까지
    while heap:
        
        weight, now = heapq.heappop(heap)
        for end, dis in node_dict[now]:
            # 조건을 만족하는 값 heap정렬
            if dp[end] > weight + dis:
                dp[end] = weight + dis
                heapq.heappush(heap, (dp[end], end))
    return dp[last]


T = int(stdin.readline())
for _ in range(T):
    n, m, t = map(int, stdin.readline().split())
    s, g, h = map(int, stdin.readline().split())


    # 노드 hash화
    node_dict = {}

    for _ in range(m):
        a, b, d = map(int, stdin.readline().split())
        node_dict[a] = node_dict.get(a,[]) + [(b,d)]
        node_dict[b] = node_dict.get(b, []) + [(a, d)]
    
    # 1번 시작 -> g -> h -> 최종
    # 2번 시작 -> h -> g -> 최종
    answer1, answer2 = 0, 0

    answer1 = dijkstra(s, g) + dijkstra(g, h)
    answer2 = dijkstra(s, h) + dijkstra(h, g)

    candidate = []
    minimum = INF
    for _ in range(t):
        node = int(stdin.readline())
        answer = min(answer1 + dijkstra(h, node), answer2 + dijkstra(g, node))
        chk_answer = dijkstra(s, node)

        if chk_answer >= answer:
            heapq.heappush(candidate, node)


    while candidate:
        print(heapq.heappop(candidate), end="")
        if candidate:
            print(" ", end="")
        else:
            print("")

문제후기

1. 해당 조건(N은 10^5보다 작거나 같은 자연수이다. 둘째 줄에 k가 주어진다. k는 min(10^9, N^2)보다 작거나 같은 자연수이다)을 확인하고 완전탐색을 하게되면 시간초과가 발생할 것을 예상했습니다. 알고리즘은 이분탐색(logN)을 활용해야겠다고 생각하게 됐습니다
2. 배열에 있는 값을 어떻게 하면 이분탐색으로 할 수 있을지 고민하는데 오래걸렸습니다. 같이 문제푸는 사람과 이야기를 하다가 몫과 나머지를 활용하면 어떻게 되지 않을까라는 말이 나와 몫을 활용하기 시작했습니다.
3. 몫을 활용해서 해당 숫자가 정답을 만족하게 되는 경우 마지막값(end)을 땡기고 만족하지 않는 경우 시작값(start)을 미루는 방식으로 진행했습니다.

자세한 예시를 들어보면

문제에서 제시한 예시 3으로 보여드리겠습니다. 3을 2차배열로 만들게 되면 아래와 같아집니다.

위의 도표를 봤을때 찾는 방식은 행의 첫번째 값을 기준으로 나누는 것입니다. 중간값은 시작(1), 마지막(9)이므로 5입니다.

1.  첫 번째 줄은 1번 값이 1. 그러므로 중간값을 1로 나누면 5//1 = 5이므로 N 3보다 크므로 5보다 작은값은 3개.
2.  두 번째 줄은 1번 값이 2. 그러므로 중간값을 2로 나누면 5//2 = 2이므로 N 3보다 작으므로 5보다 작은값은 2개.
3.  세 번째 줄은 1번 값이 3. 그러므로 중간값을 3로 나누면 5//3 = 1이므로 N 3보다 작으므로 5보다 작은값은 1개.
4. 전체 총 6개가 5보다 작습니다.
5. 시작값과 마지막값을 조정하면서 위의 과정을 반복해 K번째 값을 찾으면 됩니다.

문제링크

from sys import stdin

# Input 값
N = int(stdin.readline())
K = int(stdin.readline())

# 이분탐색 시작값과 마지막 값.
start, end = 1, N ** 2
answer = 0  # 정답값

# 이분탐색 실행.
while start <= end:
    middle = (start + end) // 2
    count = 0
    # 해당 값이 N이상으로 나눠지는지, N개인지, 그보다 적은지 판단
    # middle보다 작은 값 갯수 카운팅
    for i in range(1, N+1):
        count += min(middle//i, N)
    
    # 만약 갯수가 K보다 많거나 작으면 end값 땡겨서 범위 축소
    if count >= K:
        end = middle - 1
        answer = middle
    # 만약 갯수가 K보다 적으면 start값 땡겨서 범위 축소
    else:
        start = middle + 1
print(answer)
print(start)