Posts

N, M = map(int, input().split())

grid = [list(map(int, input().split())) for _ in range(N)]

dxy = ((0, 1), (0, -1), (1, 0), (-1, 0))


def bfs(x, y):
    q = deque([(x, y)])

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

        for dx, dy in dxy:
            nx, ny = x + dx, y + dy

            nx %= N
            ny %= M

            if grid[nx][ny] == 1:
                continue

            grid[nx][ny] = 1
            q.append((nx, ny))

    return 1


result = 0

for x in range(N):
    for y in range(M):
        if grid[x][y] == 1:
            continue

        result += bfs(x, y)

print(result)

R, C = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(R)]

N = int(input())
dxy = [list(map(int, input().split())) for _ in range(N)]

visited = [[False] * C for _ in range(R)]

q = deque()
for i, floor in enumerate(grid[0]):
    if floor == 1:
        q.append([0, i, 0])
        visited[0][i] = True

result = -1
while q:
    x, y, t = q.popleft()
    
    if x == R - 1:
        result = t
        break
    
    for dx, dy in dxy:
        nx, ny = x + dx, y + dy
        if not(0 <= nx < R and 0 <= ny < C):
            continue
        if grid[nx][ny] == 0 or visited[nx][ny]:
            continue
        
        q.append([nx, ny, t + 1])
        visited[nx][ny] = True

print(result)

P = list(map(int, input().split()))
S = list(map(int, input().split()))

def shuffle_card(cards, S):
    new_cards = [0] * (N)
    for i, n_i in enumerate(S):
        new_cards[n_i] = cards[i]
    return new_cards

cards = P[:]
answer = [0, 1, 2] * (N // 3)
cnt = 0

while answer != cards:
    cards = shuffle_card(cards, S)
    cnt += 1

    if cards == P:
        print(-1)
        break

else:
    print(cnt)

sys.setrecursionlimit(10**6)

string = sys.stdin.readline().strip()
length = len(string)

visited = [False] * length

def select_char(start, end):
    if start > end:
        return

    min_char = 'Z' + '1' 
    min_idx = -1
    for i in range(start, end + 1):
        if string[i] < min_char:
            min_char = string[i]
            min_idx = i

    visited[min_idx] = True

    current_result = ""
    for i in range(length):
        if visited[i]:
            current_result += string[i]
    print(current_result)
    select_char(min_idx + 1, end)
    select_char(start, min_idx - 1)

select_char(0, length - 1)

from copy import deepcopy
class Matrix:
    def __init__(self):
        self.size, degree = map(int, input().split())
        self.rotate_n = (degree + 360) // 45
        self.matrix = [list(map(int, input().split())) for _ in range(self.size)]
        self.mid = self.size // 2

    def rotate_matrix(self):
        new_matrix = deepcopy(self.matrix)

        for _ in range(self.rotate_n):
            for i in range(self.size):
                new_matrix[i][self.mid] = self.matrix[i][i]
                new_matrix[self.size - i - 1][i] = self.matrix[self.size - i - 1][self.mid]
                new_matrix[self.mid][i] = self.matrix[self.size - i - 1][i]
                new_matrix[i][i] = self.matrix[self.mid][i]
            self.matrix = deepcopy(new_matrix)

        return new_matrix

    def print_matrix(self):
        for row in self.matrix:
            print(*row)
    

if __name__ == "__main__":
    TC = int(input())
    for _ in range(TC):
        matrix = Matrix()
        matrix.rotate_matrix()
        matrix.print_matrix()

크기가 N×M인 배열이 있을 때, 배열을 반시계 방향으로 R번 회전시키려고 한다. 배열의 회전은 각 껍질 별로 독립적으로 일어난다.

구현 문제이다. 각 껍질을 추출하고 회전시킨 후 다시 배치한다.

gear1 = list(map(int, list(input().strip())))
gear2 = list(map(int, list(input().strip())))

len1 = len(gear1)
len2 = len(gear2)

if len1 > len2:
    gear1, gear2 = gear2, gear1
    len1, len2 = len2, len1

min_total_length = len1 + len2

for start in range(-len1 + 1, len2):
    
    for i in range(len1):
        gear2_idx = start + i
        if 0 <= gear2_idx < len2:
            # 두 개의 이가 맞물리면 안됨
            if gear1[i] == 2 and gear2[gear2_idx] == 2:
                break

    else:
        current_length = max(len2, start + len1) - min(0, start)
        min_total_length = min(min_total_length, current_length)

print(min_total_length)

import heapq

N = int(input())

lessons = []
for _ in range(N):
    i, s, e = map(int, input().split())
    lessons.append((s, e, i - 1))

lessons.sort()
room_end = [(lessons[0][1], 1)]
result = [0] * N
result[lessons[0][-1]] = 1
room_cnt = 1

for s, e, i in lessons[1:]:
    # 가장 일찍 끝나는 방
    min_end, room_i = heapq.heappop(room_end)
    # 그 방을 사용 가능할 경우
    if min_end <= s:
        heapq.heappush(room_end, (e, room_i))
        result[i] = room_i
    # 사용 못하는 경우 -> 새로운 방
    else:
        # 원래대로 복구
        heapq.heappush(room_end, (min_end, room_i))
        # 새로운 방 만들기
        room_cnt += 1
        result[i] = room_cnt
        heapq.heappush(room_end, (e, room_cnt))

print(room_cnt)
print(*result, sep='\n')

SELECT CONCAT('/home/grep/src/', b.board_id, '/', f.file_id, f.file_name, f.file_ext) as file_path
FROM used_goods_board AS b
    JOIN
    used_goods_file AS f
    ON b.board_id = f.board_id
WHERE b.views = (SELECT MAX(views) FROM used_goods_board)
ORDER BY f.file_id DESC;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 1회 JOIN 으로 두 테이블을 연결
• WHERE 로 조건에 맞는 행만 남김
• ORDER BY 로 정렬 (내림차순 포함)
• 서브쿼리를 사용
• 사용한 함수: CONCAT(), MAX()