mellowg

📡 공유기 설치

💡 문제 풀이 아이디어

• 떠올리지 못했음. 
• 이진 탐색을 통해 공유기 간의 거리를 업데이트 해나가며 구한다.

✅ 코드 (풀이 참고)

# 공유기 설치
# 이진 탐색 문제
N, C = map(int, input().split())

arr = []

for _ in range(N):
    arr.append(int(input()))
arr.sort()

start = 1 # 공유기 거리 최소
end = arr[-1] - arr[0] # 공유기 거리 최대
result = 0

# 재귀로 적절한 두 공유기 사이의 거리를 찾는다.
while(start <= end):
    mid = (start + end) // 2 # 현재 공유기 거리
    current = arr[0]
    count = 1
    # 공유기 설치 몇 대 할 수 있는지 체크
    for i in range(1, len(arr)):
        if arr[i] >= current + mid:
            count += 1
            current = arr[i]
    # 공유기 설치 수가 목표 보다 크면 공유기 사이 거리 늘림
    if count >= C:
        start = mid + 1
        result = mid
    # 공유기 설치 수가 목표 보다 작으면 공유기 사이 거리 줄임
    else:
        end = mid -1
print(result)

🌼 Binary Search (이분 탐색)

🌼 이진 탐색 알고리즘

• 순차 탐색: 리스트 안에 있는 특정한 데이터를 찾기 위해 앞에서부터 데이터를 하나씩 확인하는 방법
• 이진 탐색: 정렬되어 있는 리스트에 탐색 범위를 절반씩 좁혀가며 데이터를 탐색하는 방법
  • 이진 탐색은 시작점, 끝점, 중간점을 이용하여 탐색 범위를 설정합니다.

🌼 이진 탐색 동작 예시

• [Step 1] 시작점: 0, 끝점: 9, 중간점: 4 (소수점 이하 제거)

• [Step 2] 시작점: 0, 끝점: 3, 중간점: 1 (소수점 이하 제거)

• [Step 3] 시작점: 2, 끝점: 3, 중간점: 2 (소수점 이하 제거)

🌼 이진 탐색의 시간 복잡도

• 단계마다 탐색 범위를 2로 나누는 것과 동일하므로 연산 횟수는 log2N에 비례합니다.
• 예를 들어 초기 데이터 개수가 32개일 때, 이상적으로 1단계를 거치면 16개 가량의 데이터만 남습니다./
  • 2단계를 거치면 8개가량의 데이터만 남습니다.
  • 3단계를 거치면 4개가량의 데이터만 남습니다.
• 다시 말해 이진 탐색은 탐색 범위를 절반씩 줄이며, 시간 복잡도는 O(logN)을 보장합니다.

✅ 재귀로 구현

def binary_search(array, target, start, end):
    if start > end:
        return None
    mid = (start + end) // 2

    if array[mid] == target:
        return mid
    elif array[mid] > target:
        return binary_search(array, target, start, mid - 1)
    else:
        return binary_search(array, target, mid + 1, end)

n, target = map(int, input().split())

array = list(map(int, input().split()))

result = binary_search(array, target, 0, n - 1)
if result == None:
    print("원소가 존재하지 않습니다.")
else:
    print(result + 1)

✅ 반복문으로 구현

n, target = map(int, input().split())

array = list(map(int, input().split()))

start = 0
end = n-1

result = None
while start <= end:
    mid = (start + end) // 2
    if array[mid] < target:
        start = mid + 1
    elif array[mid] > target:
        end = mid - 1
    else:
        result = mid
        break
print(None if result == None else result + 1)

✅ 정답 코드

# 유기농 배추
from sys import stdin
from collections import deque

input = stdin.readline

def get_position():
    for i in range(N):
        for j in range(M):
            if ground[i][j] == 1:
                return (i, j)
    return (-1, -1)

def bfs(value):
    global ground
    start = get_position()

    queue = deque([start])

    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

    while queue:
        x, y = queue.popleft()
        ground[x][y] = value

        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < N and 0 <= ny < M and ground[nx][ny] == 1:
                ground[nx][ny] = value
                queue.append((nx, ny))

    if get_position() != (-1, -1):
        bfs(value + 1)


T = int(input())

for _ in range(T):
    M, N, B = map(int, input().split())
    ground = [[0] * M for _ in range(N)]
    for _ in range(B):
        x, y = map(int, input().split())
        ground[y][x] = 1
    bfs(2)

    max_value = -1
    for g in ground:
        max_value = max(max_value, max(g))
    print(max_value - 1)

🎲 주사위 굴리기

• 시간 제한: 2초
• 메모리 제한: 512MB

📄 문제

• 크기가 N x M인 지도가 존재한다. 지도의 오른쪽은 동쪽, 위쪽은 북쪽이다. 이 지도의 위에 주사위가 하나 놓여져 있으며, 주사위의 전개도는 아래와 같다. 지도의 좌표는 (r, c)로 나타내며, r는 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로부터 떨어진 칸의 개수이다.

• 주사위는 지도 위에 윗 면이 1이고, 동쪽을 바라보는 방향이 3인 상태로 놓여져 있으며, 놓여저 있는 곳의 좌표는(x, y)이다. 
• 가장 처음에 주사위에는 모든 면에 0이 적혀져 있다. 
• 지도의 각 칸에는 정수가 하나씩 쓰여져 있다. 주사위를 굴렸을 때, 이동한 칸에 쓰여 있는 수가 0이면, 주사위의 바닥면에 쓰여 있는 수가 칸에 복사된다. 0이 아닌 경우에는 칸에 쓰여 있는 수가 주사위의 바닥면에 복사되며, 칸에 쓰여 있는 수는 0이 된다. 
• 주사위는 지도의 바깥으로 이동시킬 수 없다. 만약 바깥으로 이동시키려고 하는 경우에는 해당 명령을 무시해야 하며, 출력도 하면 안된다.

입력

• 첫째 줄에 지도의 세로 크기 N, 가로 크기 M(1 <= N, M <= 20), 주사위를 놓은 곳의 좌표 x, y (0 <= x <= N -1, 0 <= y <= M -1), 그리고 명령의 개수 K( 1 <= K <= 1000)가 주어진다.
• 둘째 줄부터 N개의 줄에 지도에 쓰여 있는 수가 북쪽부터 남쪽으로, 각 줄은 서쪽부터 동쪽 순서대로 주어진다. 
• 주사위를 놓은 칸에 쓰여 있는 수는 항상 0이다.
• 지도의 각 칸에 쓰여 있는 수는 10미만의 자연수 또는 0이다.
• 마지막 줄에는 이동하는 명령이 순서대로 주어진다. 동쪽은 1, 서쪽은 2, 북쪽은 3, 남쪽은 4로 주어진다.

출력

💡 문제 풀이 아이디어

• 규칙에 맞춰 단순 구현하면 될 것 같음.
• 규칙
  1. 남쪽이동 ⬇️ 
     1. front -> down
     2. down -> back
     3. back -> up
     4. up -> front
  2. 북쪽이동 ⬆️
     1. front -> up
     2. up -> back
     3. back -> down
     4. down -> front
  3. 동쪽이동 ➡️
     1. right -> down
     2. down -> left
     3. left -> up 
     4. up -> right
  4. 서쪽이동 ⬅️
     1. left -> down
     2. down -> right
     3. right -> up
     4. up -> left

✅ 정답 코드

# 주사위 굴리기
from sys import stdin

input = stdin.readline

N, M, x, y, k = map(int, input().split())
maps = []

for _ in range(N):
    maps.append(list(map(int, input().split())))

commands = list(map(int, input().split()))

up = 0
down = 0
right = 0
front = 0
back = 0
left = 0

SOUTH, NORTH, EAST, WEST = 4, 3, 1, 2

# SOUTH => front
# NORTH => back
# EAST => left
# WEST => right

positions = (x, y)

for c in commands:

    # 이동한 칸에 쓰여 있는 수가 0이면, 주사위의 바닥면에 쓰여 있는 수가 칸에 복사된다.
    # 0이 아닌 경우에는 칸에 쓰여 있는 수가 주사위의 바닥면으로 복사되며, 칸에 쓰여 있는 수는 0이 된다.
    if c == SOUTH:
        nx, ny = positions[0] + 1, positions[1]
    elif c == NORTH:
        nx, ny = positions[0] - 1, positions[1]
    elif c == WEST:
        nx, ny = positions[0], positions[1] -1
    else:
        nx, ny = positions[0], positions[1] + 1

    # 범위 넘어가면 아무것도 안함
    if 0 <= nx < N and 0 <= ny < M:
        positions = (nx, ny)
    else:
        continue

    if c == SOUTH:
        tmp = front
        front = up
        up = back
        back = down
        down = tmp
    elif c == NORTH:
        tmp = up
        up = front
        front = down
        down = back
        back = tmp
    elif c == WEST:
        tmp = left
        left = up
        up = right
        right = down
        down = tmp
    else:
        tmp = right
        right = up
        up = left
        left = down
        down = tmp

    if maps[nx][ny] == 0:
        maps[nx][ny] = down
    else:
        down = maps[nx][ny]
        maps[nx][ny] = 0
    # print()
    # print(' ', back)
    # print(left, up, right)
    # print(' ', front)
    # print(' ', down)
    print(up)