KBR's Stacked Thoughts

1
2
3
4
5
6
7
8
9
def solution(land):
    answer = 0
    
    for i in range(1, len(land)):
        for j in range(4):
            # 같은 열을 제외한 이전 행의 최댓값
            land[i][j] += max(land[i-1][k] for k in range(4) if k != j)

    return max(land[-1])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import heapq

def solution(book_time):
    # 문자열 HH:MM을 분 단위로 변환
    def time_to_minutes(time_str):
        h, m = map(int, time_str.split(":"))
        return h * 60 + m

    # 모든 예약 시간 분으로 변환
    times = []
    for start, end in book_time:
        start_min = time_to_minutes(start)
        end_min = time_to_minutes(end) + 10  # 퇴실 후 청소 시간 포함
        times.append((start_min, end_min))

    # 시작 시간 기준으로 정렬
    times.sort()

    # 최소 힙 (퇴실+청소 시간 저장)
    room_heap = []

    for start, end in times:
        # 기존 방 중 현재 예약과 겹치지 않는 방 제거
        if room_heap and room_heap[0] <= start:
            heapq.heappop(room_heap)
        # 현재 예약 추가
        heapq.heappush(room_heap, end)

    # 남은 방의 개수가 최소 필요한 객실 수
    return len(room_heap)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from math import gcd
from functools import reduce

def solution(arrayA, arrayB):
    # 배열의 모든 수의 최대공약수 구하기
    def get_gcd(arr):
        return reduce(gcd, arr)

    # x가 상대 배열을 나누지 않는지 검사
    def is_valid(x, other_arr):
        for num in other_arr:
            if num % x == 0:
                return False
        return True

    gcdA = get_gcd(arrayA)
    gcdB = get_gcd(arrayB)

    result = 0
    if is_valid(gcdA, arrayB):
        result = max(result, gcdA)
    if is_valid(gcdB, arrayA):
        result = max(result, gcdB)

    return result

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
from collections import deque

def solution(maps):
    n, m = len(maps), len(maps[0])

    # 시작, 레버, 출구 좌표 찾기
    for i in range(n):
        for j in range(m):
            if maps[i][j] == 'S':
                start = (i, j)
            elif maps[i][j] == 'L':
                lever = (i, j)
            elif maps[i][j] == 'E':
                exit_ = (i, j)

    # BFS 함수
    def bfs(start_pos, target_char):
        visited = [[False]*m for _ in range(n)]
        q = deque()
        q.append((start_pos[0], start_pos[1], 0))
        visited[start_pos[0]][start_pos[1]] = True

        while q:
            x, y, dist = q.popleft()
            if maps[x][y] == target_char:
                return dist

            for dx, dy in [(-1,0),(1,0),(0,-1),(0,1)]:
                nx, ny = x + dx, y + dy
                if 0 <= nx < n and 0 <= ny < m:
                    if not visited[nx][ny] and maps[nx][ny] != 'X':
                        visited[nx][ny] = True
                        q.append((nx, ny, dist+1))

        return -1

    # 거리 계산
    to_lever = bfs(start, 'L')
    to_exit = bfs(lever, 'E')

    if to_lever == -1 or to_exit == -1:
        return -1
    return to_lever + to_exit

1
2
3
4
5
6
7
8
9
10
def solution(n):
    result = ''
    nums = ['4', '1', '2']
    while n > 0:
        n, r = divmod(n, 3)
        if r == 0:
            n -= 1
        result = nums[r] + result

    return result

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
from collections import deque

def solution(board):
    n, m = len(board), len(board[0])
    visited = [[False]*m for _ in range(n)]

    # 시작점(R)과 목표점(G) 찾기
    for i in range(n):
        for j in range(m):
            if board[i][j] == 'R':
                start = (i, j)
            if board[i][j] == 'G':
                goal = (i, j)

    # 상, 하, 좌, 우 방향
    directions = [(-1,0), (1,0), (0,-1), (0,1)]

    # BFS 초기화
    q = deque()
    q.append((start[0], start[1], 0))
    visited[start[0]][start[1]] = True

    while q:
        x, y, cnt = q.popleft()

        # 목표에 도달하면 종료
        if (x, y) == goal:
            return cnt

        for dx, dy in directions:
            nx, ny = x, y
            # 한 방향으로 끝까지 미끄러짐
            while 0 <= nx + dx < n and 0 <= ny + dy < m and board[nx + dx][ny + dy] != 'D':
                nx += dx
                ny += dy

            if not visited[nx][ny]:
                visited[nx][ny] = True
                q.append((nx, ny, cnt + 1))

    # 도달하지 못한 경우
    return -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def solution(maps):
    n, m = len(maps), len(maps[0])
    visited = [[False]*m for _ in range(n)]
    islands = []

    # 상하좌우 이동 방향
    directions = [(-1,0),(1,0),(0,-1),(0,1)]

    def dfs(x, y):
        stack = [(x, y)]
        total = 0
        visited[x][y] = True

        while stack:
            cx, cy = stack.pop()
            total += int(maps[cx][cy])
            for dx, dy in directions:
                nx, ny = cx+dx, cy+dy
                if 0 <= nx < n and 0 <= ny < m:
                    if not visited[nx][ny] and maps[nx][ny] != 'X':
                        visited[nx][ny] = True
                        stack.append((nx, ny))
        return total

    for i in range(n):
        for j in range(m):
            if maps[i][j] != 'X' and not visited[i][j]:
                islands.append(dfs(i, j))

    if not islands:
        return [-1]

    return sorted(islands)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def solution(n, k):
    import math

    numbers = list(range(1, n+1))
    answer = []
    k -= 1  # 0-based index로 변환

    for i in range(n, 0, -1):
        fact = math.factorial(i-1)
        index = k // fact
        answer.append(numbers.pop(index))
        k %= fact

    return answer