Koala

[백준 / python] 1003 : 피보나치 함수

sean613 — Sat, 1 Nov 2025 14:38:36 +0900

문제

https://www.acmicpc.net/problem/1003

다음 소스는 N번째 피보나치 수를 구하는 C++ 함수이다.

int fibonacci(int n) {
    if (n == 0) {
        printf("0");
        return 0;
    } else if (n == 1) {
        printf("1");
        return 1;
    } else {
        return fibonacci(n‐1) + fibonacci(n‐2);
    }
}

fibonacci(3)을 호출하면 다음과 같은 일이 일어난다.

fibonacci(3)은 fibonacci(2)와 fibonacci(1) (첫 번째 호출)을 호출한다.
fibonacci(2)는 fibonacci(1) (두 번째 호출)과 fibonacci(0)을 호출한다.
두 번째 호출한 fibonacci(1)은 1을 출력하고 1을 리턴한다.
fibonacci(0)은 0을 출력하고, 0을 리턴한다.
fibonacci(2)는 fibonacci(1)과 fibonacci(0)의 결과를 얻고, 1을 리턴한다.
첫 번째 호출한 fibonacci(1)은 1을 출력하고, 1을 리턴한다.
fibonacci(3)은 fibonacci(2)와 fibonacci(1)의 결과를 얻고, 2를 리턴한다.

1은 2번 출력되고, 0은 1번 출력된다. N이 주어졌을 때, fibonacci(N)을 호출했을 때, 0과 1이 각각 몇 번 출력되는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다.

각 테스트 케이스는 한 줄로 이루어져 있고, N이 주어진다. N은 40보다 작거나 같은 자연수 또는 0이다.

출력

각 테스트 케이스마다 0이 출력되는 횟수와 1이 출력되는 횟수를 공백으로 구분해서 출력한다.

Algorithm

0과 1의 호출 횟수 자체가 피보나치 수열을 따름

따라서 n이 0일 때 와 1 일때 호출 횟수를 입력해놓고 피보나치 수열을 따르면 됨

Code

import sys
input = sys.stdin.readline

T = int(input().strip())
N = 40

cnt0 = [0] * (N + 1)
cnt1 = [0] * (N + 1)

cnt0[0], cnt1[0] = 1, 0
cnt0[1], cnt1[1] = 0, 1

for n in range(2, N + 1):
    cnt0[n] = cnt0[n - 1] + cnt0[n - 2]
    cnt1[n] = cnt1[n - 1] + cnt1[n - 2]

for _ in range(T):
    n = int(input().strip())
    print(cnt0[n], cnt1[n])

[백준 / Python] 11047 : 동전 0

sean613 — Sun, 12 Oct 2025 11:27:25 +0900

문제

https://www.acmicpc.net/problem/11047

준규가 가지고 있는 동전은 총 N종류이고, 각각의 동전을 매우 많이 가지고 있다.

동전을 적절히 사용해서 그 가치의 합을 K로 만들려고 한다. 이때 필요한 동전 개수의 최솟값을 구하는 프로그램을 작성하시오.

문제

첫째 줄에 N과 K가 주어진다. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000)

둘째 줄부터 N개의 줄에 동전의 가치 Ai가 오름차순으로 주어진다. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2인 경우에 Ai는 Ai-1의 배수)

문제

첫째 줄에 K원을 만드는데 필요한 동전 개수의 최솟값을 출력한다.

Algorithm

동전의 가치를 스택 구조를 이용해 큰 값 부터 이용한다

큰 값 부터 몫과 나머지를 이용해 최대한 적은 개수의 동전을 이용하도록 한다

Code

import sys
input = sys.stdin.readline

N, K = map(int,input().split())
lst = []
result = 0

for i in range(N):
    lst.append(int(input()))

for i in range(N):
    temp = lst.pop()
    result += K // temp
    K = K % temp

print(result)

[백준 / Python] 2230 : 수 고르기

sean613 — Sun, 5 Oct 2025 14:26:55 +0900

문제

https://www.acmicpc.net/problem/2230

N개의 정수로 이루어진 수열 A[1], A[2], …, A[N]이 있다. 이 수열에서 두 수를 골랐을 때(같은 수일 수도 있다), 그 차이가 M 이상이면서 제일 작은 경우를 구하는 프로그램을 작성하시오.

예를 들어 수열이 {1, 2, 3, 4, 5}라고 하자. 만약 M = 3일 경우, 1 4, 1 5, 2 5를 골랐을 때 그 차이가 M 이상이 된다. 이 중에서 차이가 가장 작은 경우는 1 4나 2 5를 골랐을 때의 3이 된다.

입력

첫째 줄에 두 정수 N, M이 주어진다. 다음 N개의 줄에는 차례로 A[1], A[2], …, A[N]이 주어진다.

출력

첫째 줄에 M 이상이면서 가장 작은 차이를 출력한다. 항상 차이가 M이상인 두 수를 고를 수 있다.

Algorithm

차의 최솟값을 확인해야 하므로 투 포인터를 이용해 인덱스 0 부터 인덱스를 늘려가며 탐색한다

리스트를 오름차순으로 정렬해 탐색이 용이하게 한다

투포인터 탐색 중 left 값이 right 값보다 높아져 오류가 생길 수 있으므로 left가 right 보다 클 경우 right = left를 실행해 오류가 발생하지 않도록 한

Code

import sys
input = sys.stdin.readline

N, M = map(int,input().split())
lst = sorted([int(input()) for _ in range(N)])
left, right = 0, 0

least = float('inf')

while right < N:
    temp = lst[right] - lst[left]
    if (temp < M):
        right += 1
    else:
        least = min(least, temp)
        left += 1
        
    if left > right:
        right = left

print(least)

[백준 / Python] 1476 : 날짜 계산

sean613 — Sun, 28 Sep 2025 12:17:01 +0900

문제

https://www.acmicpc.net/problem/1476

준규가 사는 나라는 우리가 사용하는 연도와 다른 방식을 이용한다. 준규가 사는 나라에서는 수 3개를 이용해서 연도를 나타낸다. 각각의 수는 지구, 태양, 그리고 달을 나타낸다.

지구를 나타내는 수를 E, 태양을 나타내는 수를 S, 달을 나타내는 수를 M이라고 했을 때, 이 세 수는 서로 다른 범위를 가진다. (1 ≤ E ≤ 15, 1 ≤ S ≤ 28, 1 ≤ M ≤ 19)

우리가 알고있는 1년은 준규가 살고있는 나라에서는 1 1 1로 나타낼 수 있다. 1년이 지날 때마다, 세 수는 모두 1씩 증가한다. 만약, 어떤 수가 범위를 넘어가는 경우에는 1이 된다.

예를 들어, 15년은 15 15 15로 나타낼 수 있다. 하지만, 1년이 지나서 16년이 되면 16 16 16이 아니라 1 16 16이 된다. 이유는 1 ≤ E ≤ 15 라서 범위를 넘어가기 때문이다.

E, S, M이 주어졌고, 1년이 준규가 사는 나라에서 1 1 1일때, 준규가 사는 나라에서 E S M이 우리가 알고 있는 연도로 몇 년인지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 세 수 E, S, M이 주어진다. 문제에 나와있는 범위를 지키는 입력만 주어진다.

문제

첫째 줄에 E S M으로 표시되는 가장 빠른 연도를 출력한다. 1 1 1은 항상 1이기 때문에, 정답이 음수가 나오는 경우는 없다.

Algorithm

가장 작은 E(15) 를 기준으로 나머지가 E 가 나오는 수를 작은 수 부터 찾아 28로 나눈 나머지와 19로 나눈 나머지가 각각 S, M 이 나오는 최솟값을 찾는다.

28 혹은 19보다 작은 수가 답일 경우일 때 28과 19의 값에 영향을 받지 않기 때문에 S, M이 각각 28, 19인 경우 그 값을 0으로 둔다.

Code

import sys
input = sys.stdin.readline

E, S, M = map(int,input().split())
if S == 28:
    S = 0
if M == 19:
    M = 0
i = 0

while True:
    temp = 15 * i + E
    i += 1

    if (temp % 28 == S and temp % 19 == M):
        print (temp)
        break

[백준 / python] 7662 : 이중 우선순위 큐

sean613 — Sun, 21 Sep 2025 12:49:30 +0900

문제

https://www.acmicpc.net/problem/7662

이중 우선순위 큐(dual priority queue)는 전형적인 우선순위 큐처럼 데이터를 삽입, 삭제할 수 있는 자료 구조이다. 전형적인 큐와의 차이점은 데이터를 삭제할 때 연산(operation) 명령에 따라 우선순위가 가장 높은 데이터 또는 가장 낮은 데이터 중 하나를 삭제하는 점이다. 이중 우선순위 큐를 위해선 두 가지 연산이 사용되는데, 하나는 데이터를 삽입하는 연산이고 다른 하나는 데이터를 삭제하는 연산이다. 데이터를 삭제하는 연산은 또 두 가지로 구분되는데 하나는 우선순위가 가장 높은 것을 삭제하기 위한 것이고 다른 하나는 우선순위가 가장 낮은 것을 삭제하기 위한 것이다.

정수만 저장하는 이중 우선순위 큐 Q가 있다고 가정하자. Q에 저장된 각 정수의 값 자체를 우선순위라고 간주하자.

Q에 적용될 일련의 연산이 주어질 때 이를 처리한 후 최종적으로 Q에 저장된 데이터 중 최댓값과 최솟값을 출력하는 프로그램을 작성하라.

입력

입력 데이터는 표준입력을 사용한다. 입력은 T개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터의 첫째 줄에는 Q에 적용할 연산의 개수를 나타내는 정수 k (k ≤ 1,000,000)가 주어진다. 이어지는 k 줄 각각엔 연산을 나타내는 문자(‘D’ 또는 ‘I’)와 정수 n이 주어진다. ‘I n’은 정수 n을 Q에 삽입하는 연산을 의미한다. 동일한 정수가 삽입될 수 있음을 참고하기 바란다. ‘D 1’는 Q에서 최댓값을 삭제하는 연산을 의미하며, ‘D -1’는 Q 에서 최솟값을 삭제하는 연산을 의미한다. 최댓값(최솟값)을 삭제하는 연산에서 최댓값(최솟값)이 둘 이상인 경우, 하나만 삭제됨을 유념하기 바란다.

만약 Q가 비어있는데 적용할 연산이 ‘D’라면 이 연산은 무시해도 좋다. Q에 저장될 모든 정수는 -231 이상 231 미만인 정수이다.

출력

출력은 표준출력을 사용한다. 각 테스트 데이터에 대해, 모든 연산을 처리한 후 Q에 남아 있는 값 중 최댓값과 최솟값을 출력하라. 두 값은 한 줄에 출력하되 하나의 공백으로 구분하라. 만약 Q가 비어있다면 ‘EMPTY’를 출력하라.

Algorithm

최대 최소를 둘다 삭제해야하므로 최소 큐와 최대 큐를 둘다 만든다.

두개의 큐를 동기화해야하므로 uid라는 변수와 alive 라는 딕셔너리를 이용해 양쪽 큐의 상태를 동기화 할수 있게 한다.

clean_min() 과 clean_max() 함수를 이용해 양쪽의 큐를 동기화 시켜준다.

마지막 출력 전에 다시한번 clean_min() 과 clean_max() 함수를 이용해 제대로 동기화 시켜주고 결과 값을 출력한다.

Code

import sys
from heapq import heappop, heappush
input = sys.stdin.readline

def clean_min():
    while minQ and not alive.get(minQ[0][1], False):
        heappop(minQ)


def clean_max():
    while maxQ and not alive.get(maxQ[0][1], False):
        heappop(maxQ)


T = int(input())

for _ in range(T):
    k = int(input())
    maxQ = []
    minQ = []
    alive = dict()
    uid = 0

    for i in range(k):
        temp_s, temp = input().split()
        temp_i = int(temp)

        if temp_s == "I":
            alive[uid] = True
            heappush(minQ, (temp_i, uid))
            heappush(maxQ, (-temp_i, uid))
            uid += 1
        else:
            if temp_i == 1:
                clean_max()
                if maxQ:
                    _, i = heappop(maxQ)
                    alive[i] = False
            else:
                clean_min()
                if minQ:
                    _, i = heappop(minQ)
                    alive[i] = False

    clean_min()
    clean_max()

    if not minQ or not maxQ:
        print("EMPTY")
    else:
        print(-maxQ[0][0], minQ[0][0])

[백준 / Python] #23973 두 단계 최단 경로 1

dudcks — Sun, 24 Aug 2025 11:21:17 +0900

문제

알고리즘

다익스트라를 활용하여 Y노드를 포함해서 Z까지의 최단경로와, Y노드를 지나지 않고 Z까지의 최단경로를 구하는 문제이다.

Y노드를 무조건 지나는 경로는 X to Y + Y to Z의 최단경로를 서로 더해주면 된다.

Y노드를 지나지 않는 최단경로를 구할때는, 다익스트라를 반복하면서 Y노드를 방문할때 해당 계산을 무시하고 건너뛰도록 설정해주면 된다.

코드

import sys
import heapq
input = sys.stdin.readline

INF = int(1e9)

n, m = map(int, input().split())
graph = [[] for _ in range(n + 1)]

for _ in range(m):
    u, v, w = map(int, input().split())
    graph[u].append((v, w))

x, y, z = map(int, input().split())

def dijkstra(start):
    distance = [INF] * (n + 1)
    q = []
    heapq.heappush(q, (0, start))
    distance[start] = 0
    while q:
        dist, now = heapq.heappop(q)
        if distance[now] < dist:
            continue
        for i in graph[now]:
            cost = dist + i[1]
            if cost < distance[i[0]]:
                distance[i[0]] = cost
                heapq.heappush(q, (cost, i[0]))
    return distance

# x to y to z
dist_from_x = dijkstra(x)
dist_from_y = dijkstra(y)

path_x_to_y = dist_from_x[y]
path_y_to_z = dist_from_y[z]

path_with_y = -1
if path_x_to_y != INF and path_y_to_z != INF:
    path_with_y = path_x_to_y + path_y_to_z

# x to z, not visiting y
distance_no_y = [INF] * (n + 1)
q_no_y = []
heapq.heappush(q_no_y, (0, x))
distance_no_y[x] = 0

while q_no_y:
    dist, now = heapq.heappop(q_no_y)

    if distance_no_y[now] < dist:
        continue

    for i in graph[now]:
        neighbor_node = i[0]
        # if visiting node is y, ignoring
        if neighbor_node == y:
            continue

        cost = dist + i[1]

        if cost < distance_no_y[neighbor_node]:
            distance_no_y[neighbor_node] = cost
            heapq.heappush(q_no_y, (cost, neighbor_node))

path_without_y = distance_no_y[z]
if path_without_y == INF:
    path_without_y = -1

print(path_with_y, path_without_y)

[BOJ/C++] 2493번: 탑

kim2001sh — Sun, 17 Aug 2025 23:19:47 +0900

문제

풀이

N은 500000 이하이고, 제한 시간은 1.5초이므로 O(n^2) 풀이로는 해당 문항을 해결하지 못한다.

출력 양식에서 하나씩 값을 출력할 때, 앞에 있는 것 전부를 조사하지 않고 일부만 조사해서 답을 얻을 수 있는 알고리즘을 구상해야함에 주의하며 생각해보자.

오른쪽 탑 A가 왼쪽 탑 B보다 높이가 높다면, A보다 오른쪽 탑들에 대해서는 B의 정보가 필요가 없어진다. 왜냐하면 B까지 가기 전에 A에 막힐 것이기 때문이다.

따라서 스택을 활용하여 현재 탑을 쌓을 것인데, 현재보다 높이가 작은 탑을 pop하여 없애버리고, 현재 높이 이상인 처음 만난 탑부터를 남겨두는 과정을 반복하면, 탐색에 걸리는 시간이 O(1)이 되므로, 종합적으로 O(N) 시간에 해결이 가능하다.

코드

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int n, arr[500010];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> arr[i];

    deque<pair<int, int>> st; // number, height
    for (int i = 0; i < n; i++) {

        while (!st.empty() && st.back().second < arr[i]) st.pop_back();
        if (st.empty()) cout << 0 << " ";
        else cout << st.back().first << " ";
        st.push_back({ i + 1, arr[i] });
    }
}

[백준/python] 16953 A → B

ㄱㅈㅅㅇ — Sun, 17 Aug 2025 16:05:45 +0900

16953번: A → B

import sys
sys.setrecursionlimit(10000)
a,b=map(int,input().split())
ans=0
def pan(ans,a,b):
    while 1:
        if b %2 ==0:
            b//=2
            ans+=1
        else:
            b=str(b)
            if b[-1] == '1':
                b=int(b[:-1])
                ans+=1
            else:
                return -1

        if b <a:
            return -1
        elif b==a:
            return ans+1
        else:
            continue

print(pan(ans,a,b))

보통 이런 문제는 b에서 a로 가는 게 더 쉽다.

만약 b가 2로 나눠지는 애라면 1회 사용했다고 표시하고 b를 나눠준다. 그게 아니라면 b의 끝자리가 1인지 확인하고, 맞으면 1을 빼주고 또 횟수 차감해준다. 둘다 아니면 안되는 경우다. -1을 리턴하고 끝낸다. if문을 잘 거치고 나왔을 때 아직 b가 a까지 도달하지 못했다면 계속해준다. 동일하다면 그대로 끝낸다. b가 더 작다면 어떻게 해서도 만들 수 없다. -1을 리턴하고 끝낸다.

[백준/Python] 2178 : 미로 탐색

sean613 — Sun, 17 Aug 2025 13:07:36 +0900

문제

https://www.acmicpc.net/problem/2178

N×M크기의 배열로 표현되는 미로가 있다.

1	0	1	1	1	1
1	0	1	0	1	0
1	0	1	0	1	1
1	1	1	0	1	1

미로에서 1은 이동할 수 있는 칸을 나타내고, 0은 이동할 수 없는 칸을 나타낸다. 이러한 미로가 주어졌을 때, (1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수를 구하는 프로그램을 작성하시오. 한 칸에서 다른 칸으로 이동할 때, 서로 인접한 칸으로만 이동할 수 있다.

위의 예에서는 15칸을 지나야 (N, M)의 위치로 이동할 수 있다. 칸을 셀 때에는 시작 위치와 도착 위치도 포함한다.

입력

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

출력

첫째 줄에 지나야 하는 최소의 칸 수를 출력한다. 항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.

Algorithm

BFS를 최단 거리 계산에 이용

거리를 넣는 dist와 방문 여부를 넣는 visited를 이용해 탐색 결과를 저장

큐에 방문한 칸의 좌표를 넣고 목표 칸의 좌표를 popleft 했을 시 dist에서 해당 자리의 거리를 찾아 print 함

Code

from collections import deque

N, M = map(int, input().split())
maze = [input().strip() for _ in range(N)]

if maze[0][0] == '0':
    print(-1)
    sys.exit()

visited = [[False]*M for _ in range(N)]
dist = [[0]*M for _ in range(N)]
q = deque()
q.append((0, 0))
visited[0][0] = True
dist[0][0] = 1

dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

while q:
    y, x = q.popleft()
    if (y, x) == (N-1, M-1):
        print(dist[y][x])
        break

    for d in range(4):
        ny = y + dy[d]
        nx = x + dx[d]
        if 0 <= ny < N and 0 <= nx < M:
            if not visited[ny][nx] and maze[ny][nx] == '1':
                visited[ny][nx] = True
                dist[ny][nx] = dist[y][x] + 1
                q.append((ny, nx))

[백준/Python] #14496 그대, 그머가 되어

dudcks — Sun, 17 Aug 2025 12:13:22 +0900

문제

알고리즘

전형적인 bfs문제이다. 시작점인 a부터 b까지의 최소거리를 구하면 된다.

각 지점까지의 거리를 -1, 초기값으로 설정하고 a를 시작점으로 하여 bfs를 수행해주면 된다.

bfs를 수행하면서 graph 조건을 보고 거리가 갱신이 안되어있다면 현재 지점까지의 거리+1로 해당 거리를 수정해주면 된다.

코드

import sys
input = sys.stdin.readline
from collections import deque

a,b = map(int,input().split())
n,m = map(int,input().split())

graph = [[] for _ in range(n + 1)]
for _ in range(m):
    x, y = map(int, input().split())
    graph[x].append(y)
    graph[y].append(x)

distance = [-1] * (n + 1)
q = deque()

if a == b:
    print(0)
else:
    q.append(a)
    distance[a] = 0

    while q:
        v = q.popleft()
        if v == b:
            break

        for i in graph[v]:
            if distance[i] == -1:
                distance[i] = distance[v] + 1
                q.append(i)

    if distance[b] == -1:
        print(-1)
    else:
        print(distance[b])