1def solution(weights):
 2    answer = 0
 3    wdict = {}
 4    
 5    weights.sort(reverse=True)
 6    for i in weights:
 7        if i in wdict:
 8            answer += wdict[i]
 9        if i*3/2 in wdict:
10            answer += wdict[i*3/2]
11        if i*2 in wdict:
12            answer += wdict[i*2]
13        if i*4/3 in wdict:
14            answer += wdict[i*4/3]
15        
16        wdict[i] = wdict[i]+1 if i in wdict else 1
17    return answer

 1from collections import deque
 2
 3def solution(x, y, n):
 4    q = deque()
 5    visited = [False] * 1000001
 6    q.append((x, 0))
 7    
 8    while q:
 9        cx, cnt = q.popleft()
10        if cx == y:
11            return cnt
12        
13        if cx + n <= y and not visited[cx+n]:
14            q.append((cx+n, cnt+1))
15            visited[cx+n] = True
16        if cx * 2 <= y and not visited[cx*2]:
17            q.append((cx*2, cnt+1))
18            visited[cx*2] = True
19        if cx * 3 <= y and not visited[cx*3]:
20            q.append((cx*3, cnt+1))
21            visited[cx*3] = True
22    return -1

 1def solution(numbers):
 2    stack = []
 3    answer = [-1] * len(numbers)
 4
 5    for i in range(len(numbers)):
 6        while stack and stack[-1][1] < numbers[i]:
 7            answer[stack[-1][0]] = numbers[i]
 8            stack.pop()
 9        stack.append((i, numbers[i]))
10        print(stack)
11
12    return answer

 1from collections import deque
 2
 3vx = [0, 0, -1, 1]
 4vy = [-1, 1, 0, 0]
 5
 6def solution(maps):
 7    N = len(maps)
 8    M = len(maps[0])
 9    answer = []
10
11    visited = [[False]*M for _ in range(N)]
12
13    for i in range(N):
14        for j in range(M):
15            if maps[i][j] != 'X' and not visited[i][j]:
16                cnt = 0
17                q = deque()
18                q.append((j, i))
19                visited[i][j] = True
20                while q:
21                    cx, cy = q.popleft()
22                    cnt += int(maps[cy][cx])
23                    for k in range(4):
24                        nx = cx + vx[k]
25                        ny = cy + vy[k]
26                        if 0 <= nx < M and 0 <= ny < N and maps[ny][nx] != 'X' and not visited[ny][nx]:
27                            q.append((nx, ny))
28                            visited[ny][nx] = True
29                answer.append(cnt)
30    if len(answer) == 0:
31        return [-1]
32    return sorted(answer)

 1import heapq
 2
 3def time_calc(time):
 4    time_split = time.split(':')
 5    return int(time_split[0])*60 + int(time_split[1])
 6
 7def solution(book_time):
 8    time = []
 9    q = []
10    for start, end in book_time:
11        time.append((time_calc(start), time_calc(end)))
12    time.sort(key=lambda x: x[0])
13    print (time)
14    for start, end in time:
15        if q:
16            top = heapq.heappop(q)
17            if top > start:
18                heapq.heappush(q, top)
19            heapq.heappush(q, end+10)
20        else:
21            heapq.heappush(q, end+10)
22    return len(q)

 1from collections import deque
 2
 3vx = [0, 0, -1, 1]
 4vy = [-1, 1, 0, 0]
 5
 6def bfs(maps, N, M, p1, p2):
 7    visited = [[False]*M for _ in range(N)]
 8    q = deque()
 9    q.append(list(p1)+[0])
10
11    while q:
12        curY, curX, cnt = q.popleft()
13
14        if p2 == (curY, curX):
15            return cnt
16
17        for i in range(4):
18            x = curX + vx[i]
19            y = curY + vy[i]
20            if 0 <= x < M and 0 <= y < N and not visited[y][x] and maps[y][x] != 'X':
21                visited[y][x] = True
22                q.append([y, x, cnt+1])
23    return -1
24
25def solution(maps):
26    answer = 0
27    N = len(maps)
28    M = len(maps[0])
29
30    sp = (0, 0)
31    lp = (0, 0)
32    ep = (0, 0)
33
34    for i in range(N):
35        for j in range(M):
36            if maps[i][j] == 'S':
37                sp = (i, j)
38            elif maps[i][j] == 'L':
39                lp = (i, j)
40            elif maps[i][j] == 'E':
41                ep = (i, j)
42
43    tmp = bfs(maps, N, M, sp, lp)
44    if tmp == -1:
45        return -1
46
47    answer += tmp
48
49    tmp = bfs(maps, N, M, lp, ep)
50    if tmp == -1:
51        return -1
52
53    answer += tmp
54
55    return answer

 1V = [[(-1, 0), (1, 0)], [(0, -1), (0, 1)], [(-1, -1), (1, 1)], [(-1, 1), (1, -1)]]
 2P = [[(1, 0), (1, 1), (1, 2)], [(0, 1), (1, 1), (2, 1)], [(1, 1)], [(1, 1)]]
 3
 4def solution(board):
 5    answer = -1
 6    o_line = 0
 7    x_line = 0
 8
 9    for i, p_list in enumerate(P):
10        for p in p_list:
11            if board[p[0]][p[1]] != '.' and board[p[0]][p[1]]== board[p[0]+V[i][0][0]][p[1]+V[i][0][1]] == board[p[0]+V[i][1][0]][p[1]+V[i][1][1]]:
12                if board[p[0]][p[1]] == 'O':
13                    o_line += 1
14                elif board[p[0]][p[1]] == 'X':
15                    x_line += 1
16
17    o_cnt = 0
18    x_cnt = 0
19
20
21    for i in ''.join(board):
22        if i == 'O':
23            o_cnt += 1
24        elif i == 'X':
25            x_cnt += 1
26
27    if not (0 <= o_cnt - x_cnt <= 1):
28        return 0
29    if o_line == 1:
30        if o_cnt - x_cnt != 1:
31            return 0
32    if x_line == 1:
33        if o_cnt != x_cnt:
34            return 0
35    if o_line != 0 and o_line == x_line:
36        return 0
37
38    return 1

 1def solution(m, n, startX, startY, balls):
 2    answer = []
 3    for bx, by in balls:
 4        tmp = []
 5        for x, y in [(-1*startX, startY), (startX, -1*startY), (startX, 2*n-startY), (2*m-startX, startY)]:
 6            if bx==x and (y < 0 < by < startY or startY < by < n < y):
 7                continue
 8            if by==y and (x < 0 < bx < startX or startX < bx < m < x):
 9                continue
10            tmp.append ((x-bx)**2+(y-by)**2)
11        answer.append(min(tmp))
12
13
14    return answer

 1from collections import deque
 2visited = []
 3vx = [0, 0, -1, 1]
 4vy = [-1, 1, 0, 0]
 5
 6def bfs(board, N, M, sp):
 7    global visited
 8    q = deque()
 9    q.append(sp+[1])
10
11    while q:
12        cy, cx, cnt = q.popleft()
13        visited[cy][cx] = True
14        for i in range(4):
15            x = cx
16            y = cy
17            while True:
18                x += vx[i]
19                y += vy[i]
20                if not (0 <= x < N and 0 <= y < M) or board[y][x] == 'D':
21                    x -= vx[i]
22                    y -= vy[i]
23                    break
24            if board[y][x] == 'G':
25                return cnt
26            if not visited[y][x]:
27                q.append([y, x, cnt+1])
28    return -1
29
30def solution(board):
31    global visited
32    N = len(board[0])
33    M = len(board)
34
35    visited = [[False] * len(board[0]) for _ in range(len(board))]
36    for i in range(M):
37        for j in range(N):
38            if board[i][j] == 'R':
39                sp = [i, j]
40
41    return bfs(board, N, M, sp)

 1def solution(picks, minerals):
 2    bundles = []
 3    tmp = [0, 0, 0]
 4    DATA = [[1, 1, 1], [5, 1, 1], [25, 5, 1]]
 5    answer = 0
 6
 7    for i in range(len(minerals)):
 8        if minerals[i] == "diamond":
 9            for j in range(3):
10                tmp[j] += DATA[j][0]
11        elif minerals[i] == "iron":
12            for j in range(3):
13                tmp[j] += DATA[j][1]
14        elif minerals[i] == "stone":
15            for j in range(3):
16                tmp[j] += DATA[j][2]
17
18        if (i+1) % 5 == 0 or i == len(minerals)-1:
19            bundles.append(tmp)
20            tmp = [0, 0, 0]
21    bundles = bundles[:sum(picks)]
22    bundles.sort(key= lambda x: -x[2])
23
24    for i in bundles:
25        for j in range(3):
26            if picks[j] != 0:
27                answer += i[j]
28                picks[j] -= 1
29                break
30
31    return answer