반응형

티어 : 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])

메모리: 32452 KB
시간: 92 ms

반응형
반응형

마법사 상어와 파이어볼

티어 : Gold 4
시간 제한 : 1 초
메모리 제한 : 512 MB
알고리즘 분류 : 구현, 시뮬레이션

 

문제

어른 상어가 마법사가 되었고, 파이어볼을 배웠다.

마법사 상어가 크기가 N×N인 격자에 파이어볼 M개를 발사했다. 가장 처음에 파이어볼은 각자 위치에서 이동을 대기하고 있다. i번 파이어볼의 위치는 (ri, ci), 질량은 mi이고, 방향은 di, 속력은 si이다. 위치 (r, c)는 r행 c열을 의미한다.

격자의 행과 열은 1번부터 N번까지 번호가 매겨져 있고, 1번 행은 N번과 연결되어 있고, 1번 열은 N번 열과 연결되어 있다.

파이어볼의 방향은 어떤 칸과 인접한 8개의 칸의 방향을 의미하며, 정수로는 다음과 같다.

마법사 상어가 모든 파이어볼에게 이동을 명령하면 다음이 일들이 일어난다.

  1. 모든 파이어볼이 자신의 방향 di로 속력 si칸 만큼 이동한다.
    • 이동하는 중에는 같은 칸에 여러 개의 파이어볼이 있을 수도 있다.
  2. 이동이 모두 끝난 뒤, 2개 이상의 파이어볼이 있는 칸에서는 다음과 같은 일이 일어난다.
    1. 같은 칸에 있는 파이어볼은 모두 하나로 합쳐진다.
    2. 파이어볼은 4개의 파이어볼로 나누어진다.
    3. 나누어진 파이어볼의 질량, 속력, 방향은 다음과 같다.
      1. 질량은 ⌊(합쳐진 파이어볼 질량의 합)/5⌋이다.
      2. 속력은 ⌊(합쳐진 파이어볼 속력의 합)/(합쳐진 파이어볼의 개수)⌋이다.
      3. 합쳐지는 파이어볼의 방향이 모두 홀수이거나 모두 짝수이면, 방향은 0, 2, 4, 6이 되고, 그렇지 않으면 1, 3, 5, 7이 된다.
    4. 질량이 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)

메모리: 31860 KB
시간: 1236 ms

반응형

'백준 > Python' 카테고리의 다른 글

[백준 1158] 요세푸스 문제 Python  (0) 2022.04.21
[백준 10845] 큐 Python  (0) 2022.04.20
[백준 2636] 치즈 Python  (0) 2022.04.20
[백준 1743] 음식물 피하기 Python  (0) 2022.04.15
[백준 18429] 근손실 Python  (0) 2022.04.15
반응형

근손실

티어 : Silver 3
시간 제한 : 1 초
메모리 제한 : 256 MB
알고리즘 분류 : 브루트포스 알고리즘, 백트래킹

 

문제

웨이트 트레이닝을 좋아하는 어떤 대학원생은, 현재 3대 운동 중량 500의 괴력을 소유하고 있다. 다만, 하루가 지날 때마다 중량이 K만큼 감소한다. 예를 들어 K=4일 때, 3일이 지나면 중량이 488로 감소하게 된다. 따라서 운동을 하지 않고, 가만히 있다면 매일매일 중량이 감소할 뿐이다.

다행히도 이 대학원생은 N개의 서로 다른 운동 키트를 가지고 있다. 이 대학원생은 하루에 1개씩의 키트를 사용하며, 매일 어떤 키트를 사용할 지는 마음대로 결정할 수 있다. 운동 키트들은 각각의 중량 증가량을 가지고 있으며, 사용할 때마다 즉시 중량이 증가하게 된다. 이 때 몇몇 운동 키트들의 중량 증가량이 같을 수 있으나, 서로 다른 운동 키트로 간주한다. 각각의 운동 키트는 N일 동안 한 번씩만 사용할 수 있다.

대학원생은 운동 기간동안 항상 중량이 500 이상으로 유지가 되도록 N일간의 운동 플랜을 세우고자 한다. 1일차부터 N일차까지의 모든 기간동안, 어떤 시점에서라도 중량이 500보다 작아지지 않도록 해야 한다.

예를 들어 N=3, K=4일 때, 각 운동 키트의 중량 증가량이 다음과 같다고 가정하자.

이 때 1번, 3번, 2번 순서대로 운동 키트를 적용한다고 해보자. 이 경우 운동 1일차에 대학원생은 중량이 3만큼 증가하지만 그와 동시에 하루에 중량이 4만큼 감소하기 때문에, 1일이 지난 이후에 중량은 499가 된다. 따라서 조건을 만족하지 못한다.

반면에 3번, 1번, 2번 순서대로 운동 키트를 적용한다고 해보자. 그러면 1일차부터 운동을 모두 마친 날까지의 모든 시점에 대하여 항상 중량이 500이상이 된다.

N개의 운동 키트에 대한 정보가 주어졌을 때, N일간 하루에 1개씩의 운동 키트를 사용하는 모든 경우 중에서, 운동 기간동안 항상 중량이 500 이상이 되도록 하는 경우의 수를 출력하는 프로그램을 작성하시오.

위 예시에서는 모든 경우 중에서 총 4가지 경우가 조건을 만족한다.

 

입력

첫째 줄에 자연수 N K가 공백을 기준으로 구분되어 주어진다. (1 ≤ ≤ 8, 1 ≤ ≤ 50) 둘째 줄에 각 운동 키트의 중량 증가량 A가 공백을 기준으로 구분되어 주어진다. (1 ≤ ≤ 50)

 

출력

N일 동안 N개의 운동 키트를 사용하는 모든 경우 중에서, 운동 기간동안 항상 중량이 500 이상이 되도록 하는 경우의 수를 출력한다.

 

예제 입출력


Algorithm

Back Tracking
1. stack에 운동 키트 추가
    ☞ stack에 들어있지 않은 숫자만 추가
2. 운동 키트 적용 직후 중량 갱신
3. 재귀함수 호출
4. 재귀함수 return되면 중량 원상복구 후 pop
5. stack의 길이가 N이 되거나 중량이 500 미만이 되면 pop먼저 할 수 있도록 구현

 

Code

def back_tracking(now_weight):
    global answer
    
    # stack의 길이가 N이 되거나 중량이 500 미만이 되면 POP먼저 하도록 구현
    if len(stack) == N or now_weight < 500:
        pass
    else:
        for idx in range(N):
            if idx not in stack:
                stack.append(idx)
                # 중량 계산
                now_weight = now_weight - K + weights[idx]
                # 마지막 index이고 중량이 500이상이면 answer 증가
                if len(stack) == N and now_weight >= 500:
                    answer += 1
                back_tracking(now_weight)
                stack.pop()
                now_weight = now_weight + K - weights[idx]

N, K = map(int, input().split())
weights = list(map(int, input().split()))
stack = []
global answer
answer = 0
now_weight = 500
back_tracking(now_weight)
print(answer)

메모리: 30840 KB
시간: 176 ms

반응형
반응형

그룹 단어 체커

티어 : Silver 5
시간 제한 : 2 초
메모리 제한 : 128 MB
알고리즘 분류 : 구현, 문자열

 

문제

그룹 단어란 단어에 존재하는 모든 문자에 대해서, 각 문자가 연속해서 나타나는 경우만을 말한다. 예를 들면, ccazzzzbb는 c, a, z, b가 모두 연속해서 나타나고, kin도 k, i, n이 연속해서 나타나기 때문에 그룹 단어이지만, aabbbccb는 b가 떨어져서 나타나기 때문에 그룹 단어가 아니다.

단어 N개를 입력으로 받아 그룹 단어의 개수를 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 단어의 개수 N이 들어온다. N은 100보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에 단어가 들어온다. 단어는 알파벳 소문자로만 되어있고 중복되지 않으며, 길이는 최대 100이다.

 

출력

첫째 줄에 그룹 단어의 개수를 출력한다.

 

예제 입출력


Algorithm

1. 입력 받은 단어를 한 글자 씩 보면서 리스트에 이미 들어있는지 확인
2. 이미 들어있는 글자가 있다면 다음 단어 확인
3. 끝까지 이미 들어있는 글자가 없다면 그룹 단어

 

Code

import sys
input = sys.stdin.readline

N = int(input())
answer = 0
for _ in range(N):
    word = input().rstrip()
    check = [word[0]]
    flag = True # 그룹 단어인 경우 True
    for index in range(1, len(word)):
        # 이전 index의 글자와 현재 index의 글자가 같으면 continue
        if word[index-1] == word[index]:
            continue
        
        # 현재 index의 글자가 이미 리스트에 들어있다면 다음 단어 확인
        if word[index] in check:
            flag = False
            break
        elif index == len(word)-1:
            flag = True
        check.append(word[index])
    
    # flag가 True인 경우 그룹 단어
    if flag:
        answer += 1
print(answer)

메모리: 30840 KB
시간: 72 ms

반응형
반응형

카드 구매하기 2

티어 : Silver 1
시간 제한 : 1 초
메모리 제한 : 256 MB
알고리즘 분류 : 다이나믹 프로그래밍

 

문제

요즘 민규네 동네에서는 스타트링크에서 만든 PS카드를 모으는 것이 유행이다.

PS카드는 PS(Problem Solving)분야에서 유명한 사람들의 아이디와 얼굴이 적혀있는 카드이다. 각각의 카드에는 등급을 나타내는 색이 칠해져 있고, 다음과 같이 8가지가 있다.

  • 설카드
  • 레드카드
  • 오렌지카드
  • 퍼플카드
  • 블루카드
  • 청록카드
  • 그린카드
  • 그레이카드

카드는 카드팩의 형태로만 구매할 수 있고, 카드팩의 종류는 카드 1개가 포함된 카드팩, 카드 2개가 포함된 카드팩, ... 카드 N개가 포함된 카드팩과 같이 총 N가지가 존재한다.

민규는 지난주에 너무 많은 돈을 써 버렸다. 그래서 오늘은 돈을 최소로 지불해서 카드 N개를 구매하려고 한다. 카드가 i개 포함된 카드팩의 가격은 Pi원이다.

예를 들어, 카드팩이 총 4가지 종류가 있고, P1 = 1, P2 = 5, P3 = 6, P4 = 7인 경우에 민규가 카드 4개를 갖기 위해 지불해야 하는 금액의 최솟값은 4원이다. 1개 들어있는 카드팩을 4번 사면 된다.

P1 = 5, P2 = 2, P3 = 8, P4 = 10인 경우에는 카드가 2개 들어있는 카드팩을 2번 사면 4원이고, 이 경우가 민규가 지불해야 하는 금액의 최솟값이다.

카드 팩의 가격이 주어졌을 때, N개의 카드를 구매하기 위해 민규가 지불해야 하는 금액의 최솟값을 구하는 프로그램을 작성하시오. N개보다 많은 개수의 카드를 산 다음, 나머지 카드를 버려서 N개를 만드는 것은 불가능하다. 즉, 구매한 카드팩에 포함되어 있는 카드 개수의 합은 N과 같아야 한다.

 

입력

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000)

둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

 

출력

첫째 줄에 민규가 카드 N개를 갖기 위해 지불해야 하는 금액의 최솟값을 출력한다.

 

예제 입출력


Algorithm

Dynamic Programming
4장의 카드를 구매할 때 (1, 3), (2, 2) 고려
☞ (1, 3) : 1장의 카드를 구매하는 데 최적의 답 + 3장의 카드를 구매하는 데 최적의 답
☞ (2, 2) : 2장의 카드를 구매하는 데 최적의 답 + 2장의 카드를 구매하는 데 최적의 답

 

Code

N = int(input())
cards = list(map(int, input().split()))

dp = [10000*N] * (N+1)
dp[1] = cards[0]

for i in range(2, N+1):
    for j in range(1, N+1):
        # 현재 dp table에 담겨있는 값
        # j장 카드 구매하는 데 최적의 값 + i-j장 카드 구매하는 데 최적의 값
        # 카드팩으로 딱 맞게 구매할 때의 값 중 최솟값으로 갱신
        dp[i] = min(dp[i], dp[j]+dp[i-j], cards[i-1])
print(dp[-1])

메모리: 30840 KB
시간: 536 ms

반응형
반응형

카드 구매하기

티어 : Silver 1
시간 제한 : 1 초
메모리 제한 : 256 MB
알고리즘 분류 : 다이나믹 프로그래밍

 

문제

요즘 민규네 동네에서는 스타트링크에서 만든 PS카드를 모으는 것이 유행이다.

PS카드는 PS(Problem Solving)분야에서 유명한 사람들의 아이디와 얼굴이 적혀있는 카드이다. 각각의 카드에는 등급을 나타내는 색이 칠해져 있고, 다음과 같이 8가지가 있다.

  • 설카드
  • 레드카드
  • 오렌지카드
  • 퍼플카드
  • 블루카드
  • 청록카드
  • 그린카드
  • 그레이카드

카드는 카드팩의 형태로만 구매할 수 있고, 카드팩의 종류는 카드 1개가 포함된 카드팩, 카드 2개가 포함된 카드팩, ... 카드 N개가 포함된 카드팩과 같이 총 N가지가 존재한다.

민규는 카드의 개수가 적은 팩이더라도 가격이 비싸면 높은 등급의 카드가 많이 들어있을 것이라는 미신을 믿고 있다. 따라서, 민규는 돈을 최대한 많이 지불해서 카드 N개 구매하려고 한다. 카드가 i개 포함된 카드팩의 가격은 Pi원이다.

예를 들어, 카드팩이 총 4가지 종류가 있고, P1 = 1, P2 = 5, P3 = 6, P4 = 7인 경우에 민규가 카드 4개를 갖기 위해 지불해야 하는 금액의 최댓값은 10원이다. 2개 들어있는 카드팩을 2번 사면 된다.

P1 = 5, P2 = 2, P3 = 8, P4 = 10인 경우에는 카드가 1개 들어있는 카드팩을 4번 사면 20원이고, 이 경우가 민규가 지불해야 하는 금액의 최댓값이다.

마지막으로, P1 = 3, P2 = 5, P3 = 15, P4 = 16인 경우에는 3개 들어있는 카드팩과 1개 들어있는 카드팩을 구매해 18원을 지불하는 것이 최댓값이다.

카드 팩의 가격이 주어졌을 때, N개의 카드를 구매하기 위해 민규가 지불해야 하는 금액의 최댓값을 구하는 프로그램을 작성하시오. N개보다 많은 개수의 카드를 산 다음, 나머지 카드를 버려서 N개를 만드는 것은 불가능하다. 즉, 구매한 카드팩에 포함되어 있는 카드 개수의 합은 N과 같아야 한다.

 

입력

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000)

둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

 

출력

첫째 줄에 민규가 카드 N개를 갖기 위해 지불해야 하는 금액의 최댓값을 출력한다.

 

예제 입출력


Algorithm

Dynamic Programming
4장의 카드를 구매할 때 (1, 3), (2, 2) 고려
☞ (1, 3) : 1장의 카드를 구매하는 데 최적의 답 + 3장의 카드를 구매하는 데 최적의 답
☞ (2, 2) : 2장의 카드를 구매하는 데 최적의 답 + 2장의 카드를 구매하는 데 최적의 답

 

Code

N = int(input())
cards = list(map(int, input().split()))

dp = [0] * (N+1)
dp[1] = cards[0]

for i in range(2, N+1):
    for j in range(1, N+1):
        # j장의 카드를 구매하는 데 최적의 답 + i-j장의 카드를 구매하는 데 최적의 답
        # card팩으로 현재 구매 개수(i)를 한 번에 사는 경우의 답
        # 현재 dp table에 담겨있는 답 중 최댓값으로 갱신
        dp[i] = max(dp[j] + dp[i-j], cards[i-1], dp[i])

print(dp[-1])

메모리: 30840 KB
시간: 508 ms

반응형
반응형

2xn 타일링 2

티어 : Silver 3
시간 제한 : 1 초
메모리 제한 : 256 MB
알고리즘 분류 : 다이나믹 프로그래밍

 

문제

2×n 직사각형을 1×2, 2×1과 2×2 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오.

아래 그림은 2×17 직사각형을 채운 한가지 예이다.

 

입력

첫째 줄에 n이 주어진다. (1 ≤ n ≤ 1,000)

 

출력

첫째 줄에 2×n 크기의 직사각형을 채우는 방법의 수를 10,007로 나눈 나머지를 출력한다.

 

예제 입출력


Algorithm

Dynamic Programming
점화식 : dp[n] = 2 * dp[n-1] + 1 (n = 짝수)
           dp[n] = 2 * dp[n-1] - 1 (n = 홀수)

 

Code

n = int(input())
dp = [0] * (n+1)
dp[1] = 1

for num in range(2, n+1):
    # num이 짝수일 때
    if num % 2 == 0:
        dp[num] = 2 * dp[num-1] + 1
    else: # 홀수일 때
        dp[num] = 2 * dp[num-1] - 1
print(dp[n]%10007)

메모리: 30840 KB
시간: 72 ms

반응형
반응형

2xn 타일링

티어 : Silver 3
시간 제한 : 1 초
메모리 제한 : 256 MB
알고리즘 분류 : 다이나믹 프로그래밍

 

문제

2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오.

아래 그림은 2×5 크기의 직사각형을 채운 한 가지 방법의 예이다.

 

입력

첫째 줄에 n이 주어진다. (1 ≤ n ≤ 1,000)

 

출력

첫째 줄에 2×n 크기의 직사각형을 채우는 방법의 수를 10,007로 나눈 나머지를 출력한다.

 

예제 입출력


Algorithm

Dynamic Programming
점화식 : dp[n] = dp[n-2] + dp[n-1]

 

Code

n = int(input())
dp = [0] * (n+1)
dp[1] = 1
if n > 1:
    dp[2] = 2

for num in range(3, n+1):
    dp[num] = dp[num-1] + dp[num-2]
print(dp[n]%10007)

메모리: 30840 KB
시간: 68 ms

반응형

'백준 > Python' 카테고리의 다른 글

[백준 11052] 카드 구매하기 Python  (0) 2022.04.13
[백준 11727] 2xn 타일링 2 Python  (0) 2022.04.12
[백준 1463] 1로 만들기 Python  (0) 2022.04.12
[백준 1182] 부분수열의 합 Python  (0) 2022.04.12
[백준 11723] 집합 Python  (0) 2022.04.12

+ Recent posts