티어 : Silver 4 시간 제한 : 1 초 메모리 제한 : 256 MB 알고리즘 분류 : 자료 구조, 정렬, 이분 탐색
문제
숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.
입력
첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
출력
첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.
예제 입출력
Algorithm
1. 숫자 입력받을 때 Dictionary에 해당 숫자 개수 저장 2. M개 숫자에 대해 Dictionary의 value 출력
Code
# Dictionary 이용
N = int(input())
num_list = list(map(int, input().split()))
nums = {}
for num in num_list:
if num not in nums:
nums[num] = 1
else:
nums[num] += 1
M = int(input())
num_list = list(map(int, input().split()))
for num in num_list:
if num in nums:
print(nums[num], end = ' ')
else:
print(0, end = ' ')
메모리: 132176 KB 시간: 936 ms
# bisect 이용
import bisect
N = int(input())
num_list = list(map(int, input().split()))
# 오름차순 정렬
num_list.sort()
M = int(input())
lists = list(map(int, input().split()))
for num in lists:
first = bisect.bisect_left(num_list, num)
second = bisect.bisect_right(num_list, num)
print(second-first, end = ' ')
티어 : Silver 4 시간 제한 : 0.5 초 (추가 시간 없음) 메모리 제한 : 256 MB 알고리즘 분류 : 자료 구조, 덱
문제
정수를 저장하는 덱(Deque)를 구현한 다음, 입력으로 주어지는 명령을 처리하는 프로그램을 작성하시오.
명령은 총 여덟 가지이다.
push_front X: 정수 X를 덱의 앞에 넣는다.
push_back X: 정수 X를 덱의 뒤에 넣는다.
pop_front: 덱의 가장 앞에 있는 수를 빼고, 그 수를 출력한다. 만약, 덱에 들어있는 정수가 없는 경우에는 -1을 출력한다.
pop_back: 덱의 가장 뒤에 있는 수를 빼고, 그 수를 출력한다. 만약, 덱에 들어있는 정수가 없는 경우에는 -1을 출력한다.
size: 덱에 들어있는 정수의 개수를 출력한다.
empty: 덱이 비어있으면 1을, 아니면 0을 출력한다.
front: 덱의 가장 앞에 있는 정수를 출력한다. 만약 덱에 들어있는 정수가 없는 경우에는 -1을 출력한다.
back: 덱의 가장 뒤에 있는 정수를 출력한다. 만약 덱에 들어있는 정수가 없는 경우에는 -1을 출력한다.
입력
첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지 않은 명령이 주어지는 경우는 없다.
출력
출력해야하는 명령이 주어질 때마다, 한 줄에 하나씩 출력한다.
예제 입출력
Algorithm
Dequeue, 구현-Simulation
Code
from collections import deque
import sys
input = sys.stdin.readline
N = int(input())
queue = deque()
for _ in range(N):
order = input().rstrip()
# 빈칸이 들어있으면 명령어와 숫자 분리
if ' ' in order:
order, num = order.split()
num = int(num)
if order == 'push_front':
queue.appendleft(num)
elif order == 'push_back':
queue.append(num)
elif order == 'pop_front':
# 덱에 들어있는 정수가 없는 경우 -1 출력
if not queue:
print(-1)
else:
print(queue[0])
queue.popleft()
elif order == 'pop_back':
# 덱에 들어있는 정수가 없는 경우 -1 출력
if not queue:
print(-1)
else:
print(queue[-1])
queue.pop()
elif order == 'size':
print(len(queue))
elif order == 'empty':
# 덱이 비어있으면 1, 비어있지 않으면 0 출력
if not queue:
print(1)
else:
print(0)
elif order == 'front':
# 덱에 들어있는 정수가 없는 경우 -1 출력
if not queue:
print(-1)
else:
print(queue[0])
else:
# 덱에 들어있는 정수가 없는 경우 -1 출력
if not queue:
print(-1)
else:
print(queue[-1])
티어 : Gold 5 시간 제한 : 1 초 메모리 제한 : 128 MB 알고리즘 분류 : 그래프 이론, 다익스트라
문제
농부 현서는 농부 찬홍이에게 택배를 배달해줘야 합니다. 그리고 지금, 갈 준비를 하고 있습니다. 평화롭게 가려면 가는 길에 만나는 모든 소들에게 맛있는 여물을 줘야 합니다. 물론 현서는 구두쇠라서 최소한의 소들을 만나면서 지나가고 싶습니다.
농부 현서에게는 지도가 있습니다. N (1 <= N <= 50,000) 개의 헛간과, 소들의 길인 M (1 <= M <= 50,000) 개의 양방향 길이 그려져 있고, 각각의 길은 C_i (0 <= C_i <= 1,000) 마리의 소가 있습니다. 소들의 길은 두 개의 떨어진 헛간인 A_i 와 B_i (1 <= A_i <= N; 1 <= B_i <= N; A_i != B_i)를 잇습니다. 두 개의 헛간은 하나 이상의 길로 연결되어 있을 수도 있습니다. 농부 현서는 헛간 1에 있고 농부 찬홍이는 헛간 N에 있습니다.
농부 현서가 선택할 수 있는 최선의 통로는 1 -> 2 -> 4 -> 5 -> 6 입니다. 왜냐하면 여물의 총합이 1 + 0 + 3 + 1 = 5 이기 때문입니다.
농부 현서의 지도가 주어지고, 지나가는 길에 소를 만나면 줘야할 여물의 비용이 주어질 때 최소 여물은 얼마일까요? 농부 현서는 가는 길의 길이는 고려하지 않습니다.
입력
첫째 줄에 N과 M이 공백을 사이에 두고 주어집니다.
둘째 줄부터 M+1번째 줄까지 세 개의 정수 A_i, B_i, C_i가 주어집니다.
출력
첫째 줄에 농부 현서가 가져가야 될 최소 여물을 출력합니다.
예제 입출력
Algorithm
최단거리 - Dijkstra 1. 양방향 그래프 생성 2. Dijkstra 최단거리 구하기
Code
def dijkstra(start):
queue = []
# 시작 노드로 가는 최단 경로 0으로 설정
heapq.heappush(queue, (start, 0))
distance[start] = 0
while queue:
# 최단거리가 가장 짧은 노드 꺼내기
now, dist = heapq.heappop(queue)
# 이미 처리된 적 있는 노드인지 확인
if distance[now] < dist:
continue
# 인접한 헛간으로 이동
for i, C in graph[now]:
cost = dist + C
# 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우
if cost < distance[i]:
distance[i] = cost
heapq.heappush(queue, (i, cost))
import heapq
import sys
input = sys.stdin.readline
INF = 10e9
N, M = map(int, input().split())
graph = [[] for _ in range(N+1)]
distance = [INF for _ in range(N+1)]
visited = [False for _ in range(N+1)]
for _ in range(M):
A, B, C = map(int, input().split())
graph[A].append((B, C))
graph[B].append((A, C))
dijkstra(1)
print(distance[-1])
티어 : Silver 1 시간 제한 : 2 초 메모리 제한 : 128 MB 알고리즘 분류 : 다이나믹 프로그래밍
문제
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
위 그림은 크기가 5인 정수 삼각형의 한 모습이다.
맨 위층 7부터 시작해서 아래에 있는 수 중 하나를 선택하여 아래층으로 내려올 때, 이제까지 선택된 수의 합이 최대가 되는 경로를 구하는 프로그램을 작성하라. 아래층에 있는 수는 현재 층에서 선택된 수의 대각선 왼쪽 또는 대각선 오른쪽에 있는 것 중에서만 선택할 수 있다.
삼각형의 크기는 1 이상 500 이하이다. 삼각형을 이루고 있는 각 수는 모두 정수이며, 범위는 0 이상 9999 이하이다.
입력
첫째 줄에 삼각형의 크기 n(1 ≤ n ≤ 500)이 주어지고, 둘째 줄부터 n+1번째 줄까지 정수 삼각형이 주어진다.
N = int(input())
table = [[] for _ in range(N+1)]
for i in range(1, N+1):
table[i] += list(map(int, input().split()))
dp = [[] for _ in range(N+1)]
for i in range(N+1):
for j in range(i):
dp[i].append(0)
dp[1] = table[1]
for i in range(1, len(table)-1):
for j in range(len(table[i])):
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + table[i+1][j])
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + table[i+1][j+1])
print(max(dp[-1]))
티어 : Silver 4 시간 제한 : 2 초 메모리 제한 : 256 MB 알고리즘 분류 : 자료구조, 큐
문제
요세푸스 문제는 다음과 같다.
1번부터 N번까지 N명의 사람이 원을 이루면서 앉아있고, 양의 정수 K(≤ N)가 주어진다. 이제 순서대로 K번째 사람을 제거한다. 한 사람이 제거되면 남은 사람들로 이루어진 원을 따라 이 과정을 계속해 나간다. 이 과정은 N명의 사람이 모두 제거될 때까지 계속된다. 원에서 사람들이 제거되는 순서를 (N, K)-요세푸스 순열이라고 한다. 예를 들어 (7, 3)-요세푸스 순열은 <3, 6, 2, 7, 5, 1, 4>이다.
N과 K가 주어지면 (N, K)-요세푸스 순열을 구하는 프로그램을 작성하시오.
입력
첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ N ≤ 5,000)
출력
예제와 같이 요세푸스 순열을 출력한다.
예제 입출력
Algorithm
구현 1. list의 index에 해당하는 숫자 answer에 저장하고 remove 2. index의 값 K씩 증가시키며 list 비어있지 않을 때만 반복되도록 구현
Code
N, K = map(int, input().split())
nums = list(range(1, N+1))
index = K-1
answer = []
while True:
# 현재 index의 사람 없애기
answer.append(nums[index])
nums = nums[:index] + nums[index+1:]
if not nums:
break
index = (index + K-1) % len(nums)
print('<' + ', '.join(list(map(str, answer))) + '>')
티어 : Silver 4 시간 제한 : 0.5 초 (추가 시간 없음) 메모리 제한 : 256 MB 알고리즘 분류 : 자료 구조, 큐
문제
정수를 저장하는 큐를 구현한 다음, 입력으로 주어지는 명령을 처리하는 프로그램을 작성하시오.
명령은 총 여섯 가지이다.
push X: 정수 X를 큐에 넣는 연산이다.
pop: 큐에서 가장 앞에 있는 정수를 빼고, 그 수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.
size: 큐에 들어있는 정수의 개수를 출력한다.
empty: 큐가 비어있으면 1, 아니면 0을 출력한다.
front: 큐의 가장 앞에 있는 정수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.
back: 큐의 가장 뒤에 있는 정수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.
입력
첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지 않은 명령이 주어지는 경우는 없다.
출력
출력해야하는 명령이 주어질 때마다, 한 줄에 하나씩 출력한다.
예제 입출력
Algorithm
구현 - Simulation, Queue
Code
import sys
from collections import deque
input = sys.stdin.readline
N = int(input())
queue = deque()
for _ in range(N):
orders = input().rstrip()
# orders에 공백이 포함되어있으면 나누기
if ' ' in orders:
order, num = orders.split()
num = int(num)
else:
order = orders
if order == 'push':
queue.append(num)
elif order == 'pop':
# 정수가 없는 경우
if not queue:
print(-1)
else:
print(queue[0])
queue.popleft()
elif order == 'size':
print(len(queue))
elif order == 'empty':
# 비어있으면 1
if not queue:
print(1)
else:
print(0)
elif order == 'front':
# 큐에 정수가 없으면 -1 출력
if not queue:
print(-1)
else:
print(queue[0])
else:
# 큐에 정수가 없으면 -1 출력
if not queue:
print(-1)
else:
print(queue[-1])
마법사 상어가 크기가 N×N인 격자에 파이어볼 M개를 발사했다. 가장 처음에 파이어볼은 각자 위치에서 이동을 대기하고 있다. i번 파이어볼의 위치는 (ri, ci), 질량은 mi이고, 방향은 di, 속력은 si이다. 위치 (r, c)는 r행 c열을 의미한다.
격자의 행과 열은 1번부터 N번까지 번호가 매겨져 있고, 1번 행은 N번과 연결되어 있고, 1번 열은 N번 열과 연결되어 있다.
파이어볼의 방향은 어떤 칸과 인접한 8개의 칸의 방향을 의미하며, 정수로는 다음과 같다.
마법사 상어가 모든 파이어볼에게 이동을 명령하면 다음이 일들이 일어난다.
모든 파이어볼이 자신의 방향 di로 속력 si칸 만큼 이동한다.
이동하는 중에는 같은 칸에 여러 개의 파이어볼이 있을 수도 있다.
이동이 모두 끝난 뒤, 2개 이상의 파이어볼이 있는 칸에서는 다음과 같은 일이 일어난다.
같은 칸에 있는 파이어볼은 모두 하나로 합쳐진다.
파이어볼은 4개의 파이어볼로 나누어진다.
나누어진 파이어볼의 질량, 속력, 방향은 다음과 같다.
질량은 ⌊(합쳐진 파이어볼 질량의 합)/5⌋이다.
속력은 ⌊(합쳐진 파이어볼 속력의 합)/(합쳐진 파이어볼의 개수)⌋이다.
합쳐지는 파이어볼의 방향이 모두 홀수이거나 모두 짝수이면, 방향은 0, 2, 4, 6이 되고, 그렇지 않으면 1, 3, 5, 7이 된다.
질량이 0인 파이어볼은 소멸되어 없어진다.
마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 구해보자.
입력
첫째 줄에 N, M, K가 주어진다.
둘째 줄부터 M개의 줄에 파이어볼의 정보가 한 줄에 하나씩 주어진다. 파이어볼의 정보는 다섯 정수 ri, ci, mi, si, di로 이루어져 있다.
서로 다른 두 파이어볼의 위치가 같은 경우는 입력으로 주어지지 않는다.
출력
마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 출력한다.
제한
4 ≤ N ≤ 50
0 ≤ M ≤ N2
1 ≤ K ≤ 1,000
1 ≤ ri, ci≤ N
1 ≤ mi≤ 1,000
1 ≤ si≤ 1,000
0 ≤ di≤ 7
예제 입출력
Algorithm
구현 - Simulation 1. 리스트에 명령들 담음 2. 모든 파이어볼 이동 ☞ graph에 각 칸마다 존재하는 파이어볼의 개수 갱신 3. 그래프 전체를 보면서 값이 2 이상인 경우 질량, 속력, 방향 계산해 명령을 담는 리스트에 추가 ☞ 질량이 0이면 추가하지 않음 4. K번째 명령이 끝아면 질량의 총합 구함
Code
import sys
input = sys.stdin.readline
N, M, K = map(int, input().split())
graph = [[[] for _ in range(N)] for _ in range(N)]
orders = []
for _ in range(M):
r, c, m, s, d = map(int, input().split())
orders.append((r-1, c-1, m, s, d))
graph[r-1][c-1].append((m, s, d))
# 상, 우상향, 우, 우하향, 하, 좌하향, 좌, 좌상향
directions = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
for count in range(K):
# 파이어볼 이동
for r, c, m, s, d in orders:
dx = directions[d][0] * s
dy = directions[d][1] * s
graph[r][c] = graph[r][c][1:]
graph[(r+dx)%N][(c+dy)%N].append((m, s, d))
orders = []
for x in range(N):
for y in range(N):
# 파이어볼이 1개인 칸은 다음 명령에 추가
if len(graph[x][y]) == 1:
m, s, d = graph[x][y][0]
orders.append((x, y, m, s, d))
# 파이어볼이 2개 이상인 칸에서
elif len(graph[x][y]) > 1:
# 질량, 속력, 방향 구하기
sum_m = 0
sum_s = 0
check_d = [0, 0]
for m, s, d in graph[x][y]:
sum_m += m
sum_s += s
check_d[d%2] += 1
m = sum_m // 5
# 질량이 0인 파이어볼 소멸
if m == 0:
graph[x][y] = []
continue
s = sum_s // len(graph[x][y])
# 파이어볼 뱡향이 모두 홀수이거나 짝수이면 0, 2, 4, 6
graph[x][y] = []
if check_d[0] * check_d[1] == 0:
for d in range(0, 7, 2):
orders.append((x, y, m, s, d))
graph[x][y].append((m, s, d))
else:
for d in range(1, 8, 2):
orders.append((x, y, m, s, d))
graph[x][y].append((m, s, d))
# graph에 있는 질량의 합 구하기
answer = 0
for x in range(N):
for y in range(N):
for m, s, d in graph[x][y]:
answer += m
print(answer)
