KBR's Stacked Thoughts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def solution(routes):
    ### 1. 진출 지점 기준으로 오츰차순 정렬
    routes.sort(key=lambda x:x[1])
    
    ### 2. 첫 번째 차량의 진출 지점에 카메라 설치
    camera_position = routes[0][1]
    answer = 1
    
    ### 3. 반복문으로 나머지 차량 검사
    for route in routes[1:]:
        # 현재 차량의 진입 지점이 카메라 위치보다 뒤에 있으면 새 카메라 설치
        if route[0] > camera_position:
            answer += 1
            # 진출 지점에 설치
            camera_position = route[1]
            
    return answer

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
def solution(n, costs):
    ### 1. 비용 기준으로 간선 정렬
    costs.sort(key=lambda x: x[2])
    
    ### 2. 부모 배열 초기화
    parent = [i for i in range(n)]
    
    # 대표 노드를 찾는 find 함수 정의
    def find(x):
        if parent[x] != x:
            parent[x] = find(parent[x])
        return parent[x]
    
    # 두 노드를 연결하는 union 함수 정의
    def union(a, b):
        root_a = find(a)
        root_b = find(b)
        if root_a != root_b:
            parent[root_b] = root_a
            return True
        return False
    
    ### 3. 최소 비용 계산
    total_cost = 0
    edge_count = 0
    
    for a, b, cost in costs:
        # 다른 집합이면
        if union(a, b):
            total_cost += cost
            edge_count += 1
            # n - 1개의 간선이 될 때까지 반복
            if edge_count == n - 1:
                break
    
    return total_cost

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def solution(n, computers):
    ### 1. 방문 여부를 기록할 리스트 정의
    visited = [False] * n
    answer = 0
    
    ### DFS 함수 정의
    def dfs(current):
        visited[current] = True
        for neighbor in range(n):
            if computers[current][neighbor] == 1 and not visited[neighbor]:
                dfs(neighbor)
                
    # 방문하지 않은 컴퓨터면 새로운 네트워크 시작
    for i in range(n):
        if not visited[i]:
            dfs(i)
            answer += 1
    
    return answer

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
from collections import deque

def solution(begin, target, words):
    # target이 words에 없으면 0 리턴
    if target not in words:
        return 0
    
    def is_one_char_diff(word1, word2):
        diff_count = sum(1 for a, b in zip(word1, word2) if a != b)
        return diff_count == 1
    
    visited = set()
    # (현재 단어, 변환 횟수)
    queue = deque([(begin, 0)])
    
    while queue:
        current_word, steps = queue.popleft()
        
        if current_word == target:
            return steps
        
        for word in words:
            if word not in visited and is_one_char_diff(current_word, word):
                visited.add(word)
                queue.append((word, steps + 1))
    
    return 0

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
from collections import defaultdict

def solution(tickets):
    graph = defaultdict(list)
    
    ### 1. 그래프 구성
    for src, dst in tickets:
        graph[src].append(dst)
    for src in graph:
        graph[src].sort()
        
    # 최종 경로
    answer = []
    ticket_count = len(tickets)
    
    def dfs(current, path):
        if len(path) == ticket_count + 1:
            # 모든 티켓을 사용했을 때
            answer.extend(path)
            return True
        
        if current not in graph:
            return False
        
        # 백트래킹을 위한 배열 저장
        temp_list = list(graph[current])
        
        for i, next_dest in enumerate(temp_list):
            #티켓 사용
            graph[current].pop(i)
            if dfs(next_dest, path + [next_dest]):
                return True
            graph[current].insert(i, next_dest)
        
        return False
    
    dfs("ICN", ["ICN"])
    return answer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from collections import defaultdict

def solution(genres, plays):
    genre_to_songs = defaultdict(list)
    genre_play_count = defaultdict(int)
    
    ### 1-2. 장르별 곡 정보와 재생 수 저장
    for idx, (genre, play) in enumerate(zip(genres, plays)):
        genre_to_songs[genre].append((play, idx))
        genre_play_count[genre] += play
        
    ### 3. 장르를 총 재생 수 기준으로 내림차순 정렬
    sorted_genres = sorted(genre_play_count.items(), key=lambda x: x[1], reverse=True)
    answer = []
    
    ### 4. 각 장르 내에서 곡 정렬 후 상위 두 개 선택
    for genre, _ in sorted_genres:
        # 재생 수 내림차순 >> 고유 번호 오름차순 정렬
        songs = sorted(genre_to_songs[genre], key=lambda x: (-x[0], x[1]))
        top_songs = songs[:2]  # 최대 두 곡
        answer.extend([idx for _, idx in top_songs])
    return answer

1
2
def solution(n):
    return [int(ch) for ch in str(n)[::-1]]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def solution(arr, divisor):
    answer = []
    for i in range(len(arr)):
        if arr[i] % divisor == 0:
            answer.append(arr[i])
    
    if len(answer) == 0:
        return [-1]
    else: 
        return sorted(answer)

# --- 더 간단한 버전
def solution(arr, divisor):
		answer = sorted([x for x in arr if x % divisor == 0])
		return answer if answer else [-1]

1
2
3
4
5
6
7
8
def solution(n, left, right):
    answer = []
    
    for i in range(left, right + 1):
        row = i // n
        col = i % n
        answer.append(max(row, col) + 1)
    return answer