프레소님의 블로그

AI · SW 마에스트로 17기 지원 후기 (최종합격)

PRESSO_ — Sat, 21 Mar 2026 13:06:04 +0900

자기소개서

SW마에스트로에서 자기소개서는 진짜 기본적인 내용만 적어도 통과된다.
지금까지 SW마에스트로에 여러 번 지원했는데 한번도 자기소개서 단계에서 떨어진 적은 없다.
~~2020년에도 지원했었는데 자기소개서 작성 전에 다시 보니 가관이였다... ㅋㅋㅋ~~

하지만, 면접에서 자기소개서에 적은 내용과 프로젝트 관련 질문이 들어오기 때문에 처음부터 잘 쓰는 것이 좋다.

필자는 이전 직장에서 했던 경험, 관련 프로젝트를 이어서 하고 싶다는 식으로 작성했다.

1차 코딩테스트

1차 코딩테스트는 생각보다 쉬웠다. 별 다른 문제가 없다면 올솔했을 것으로 예상한다.

가장 어려웠던 문제도 솔브드 티어 기준으로 골드 5정도?
이마저도 특정 자료구조를 사용하라는 힌트가 문제에 주어져서 난이도가 하락했다.

예상했던 대로 1차 코딩테스트에서는 알고리즘보다는 구현, 자료구조에서 문제가 나왔다.

유사한 문제

[알고리즘 / 프로그래머스] 완주하지 못한 선수
[알고리즘 / 프로그래머스] 디스크 컨트롤러
[알고리즘 / 백준] 문자열 폭발
[SQL / 프로그래머스] 오프라인/온라인 판매 데이터 통합하기

결과

올솔한걸로 예상했기 때문에 편한 마음으로 결과 발표를 기다리고 있었다.
결과는 통과

2차 코딩테스트

2차 코딩테스트는 브루트포스, DP, 알고리즘 관련 문제가 나온다.

필자는 알고리즘 1번 0.8솔, 2번 1솔로 총 1.8솔 했을 것으로 예상한다.

1번 문제는 구현 & 브루트포스 문제로,
평가 조건을 안읽고 제한시간이 10초인 것만 봐서 O(N^4)로 풀었다.
그런데 마지막 조건에서 N이 최대 1,000까지 들어갈 수 있기 때문에 시간초과가 나게 된다.

2번 문제는 전형적인 DP 문제로, 깔끔하게 잘 풀은 것 같다.
처음에는 점화식이 생각나지 않아 BFS로 풀려다가 무조건 시간초과가 날 것 같아 급하게 다시 DP로 전환했다.

이 두 문제를 풀었을 때 1시간가량이 남았고, 3번은 뭔가 트리, 4번은 그래프 탐색 문제처럼 보여서 4번을 선택했다.
그런데 4번 문제가 생각보다 조건이 까다롭고, 제약 조건이 많아 결국 풀지 못하고 끝나버렸다.
~~SQL 문제는 아예 읽지도 못했다...~~

결과

SW마에스트로 오픈채팅방 투표를 보고 2솔에 사람 투표한 사람이 많아 긴장됐다.
다행히도 통과해서 심층면접까지 볼 수 있었다.

심층면접

준비과정

2차 코딩테스트를 통과한다는 확신이 없어서 발표 전까지 따로 면접 준비는 하지 않았는데 통과해서...ㅋㅋㅋ
부랴부랴 면접 준비를 시작했다.

심층면접은 작성한 포트폴리오로 개인별 발표(3분), 질의응답(12분)으로 한 사람당 총 15분의 시간이 배정된다.
면접은 5:5로 진행되며, 같은 시간에 여러 분과로 나뉘어져 한 타임에 총 25명이 면접을 진행한다.

발표 후 면접까지는 9일정도 남아서 3일은 포트폴리오, 1 ~ 2일은 대본, 나머지 시간은 대본 암기와 예상질문 대비하는데 시간을 보냈다.

면접 3일 전에는 오픈채팅방에서 열린 모의 면접에 참여했다.
이 경험이 실제 면접에서 많이 도움이 되었는데, 발표에 시간이 얼마나 걸리는지 미리 알 수 있고,
다들 예상 질문을 잘 준비해주셔서 실제 면접에서 유사한 질문이 나오기도 했다.

면접 전까지 대본을 전부 외워서 발표때 절지 않고 잘 발표할 수 있었다.
길에서 연습하고... 학교 강의시간에 연습하고... 자다 일어나자마자 발표해도 발표할 수 있을 정도로 완벽하게 암기했다.

면접 당일

발표 당일에는 학교의 캡스톤디자인 제안발표를 먼저 해서 긴장을 완화했다.
~~1대30 발표도 했는데 5대5 면접은 별것도 아니지라는 마인드로~~

면접 전에 1시간 반정도 먼저 가서 근처 카페에서 기다리고 있었는데,
딱 봐도 SW마에스트로 면접 보러 오신분이 계셔서 먼저 인사하고 같이 면접 준비를 진행했다.

같이 면접 준비를 하다보니 시간이 돼서 면접장에 들어갔다.

들어가면 본인 분과, 발표 순번이 적혀있는 명찰을 나눠주시고 기다리고 있다 보면 발표에 관해서 설명해주신다.

면접

면접은 딱 설명해주신대로 진행되었다.
들어가면 순번대로 각자 준비한 포트폴리오를 띄워두고 발표를 진행한다.

면접 진행이나 나왔던 문항은 규정상 적기 어려워서 패스
생각보다 기술 질문이 많이 나오지 않아서 당황한 기억이 있다.

결과

AI·SW 마에스트로 17기 연수생으로 최종 선발됐다 ㅎㅎㅎ

면접 때 기술질문이 별로 안들어와서 좀 걱정이 됐는데 다행이도 선발돼었다.

1년동안 다양한 사람들을 만나고 프로젝트를 진행하며 더 성장한 내가 돼길 바란다.

[백준 / BOJ] 1028 다이아몬드 광산 (Python)

PRESSO_ — Thu, 5 Mar 2026 15:51:30 +0900

문제 링크

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

사용 알고리즘

DP
누적 합

풀이

주어진 배열 안에서 나타나는 가장 큰 다이아몬드 모양의 크기를 구하는 문제이다.

첫 시도에는 주어진 행, 열의 크기에 따라 나타날 수 있는 모든 다이아몬드 모양의 좌표를 저장해두고 각 모양마다 해당 모양을 만족하는 경우가 있는지 확인하는 식으로 구현했지만 시간 초과가 발생해서 다른 사람의 풀이를 보고 해결했다.

이 문제를 풀기 위해서는 다이아몬드의 성질을 파악해야 한다.

특정 좌표를 다이아몬드 모양의 가장 왼쪽 좌표가 `(y, x)`라고 가정했을 경우,

`(y, x)`에서부터 우측 상단, 우측 하단으로 연속된 1의 개수와

`(y, x + 2 * (size - 1))`좌표에서의 좌측 상단, 좌측 하단으로 연속된 1의 개수가 size 보다 크다면 해당 크기의 다이아몬드 모양을 만들 수 있다.

예제

입력

5 5
01100
01011
11111
01111
11111

출력

3

아래 사진과 같은 입력이 주어질 경우, 이 중 가장 큰 크기의 다이아몬드 모양은 다이아몬드 모양의 가장 왼쪽 좌표가 (2, 0)인 크기 3인 다이아몬드이다.

이를 구하기 위해 각 좌표에서 우측 상단, 우측 하단, 좌측 상단, 좌측 하단으로 연속된 1의 개수를 카운팅해주자.

이 때, DP를 이용하면 보다 빠른 속도로 연속된 1의 개수를 구할 수 있다.

(0, 0)부터 탐색을 진행한다고 가정하고, 현재 좌표가 (2, 0)일 경우를 보자.

(2, 0)에서 만들 수 있는 다이아몬드의 최대 크기는 `우측 상단, 우측 하단 중 최소값 = 3`이므로 크기가 3인 다이아몬드를 만들 수 있는지 확인해보자.

다이아몬드를 만들기 위해선 다이아몬드의 가장 우측 좌표에서 각각 좌측 상단, 좌측 하단으로 뻗어나가는 크기가 3보다 크거나 같아야 한다.

다이아몬드의 가장 좌측 좌표가 (2, 0)이고 크기가 3이므로 다이아몬드의 가장 우측 좌표는 `(2, 0 + 2 * (3 - 1)) = (2, 4)`이 된다.

(2, 4) 좌표에서 좌측 상단, 좌측 하단으로 연속되어 있는 1의 수가 각각 3, 3이기 때문에 이를 만족한다.

이 순서대로 반복하면 가장 큰 다이아몬드 모양의 크기를 구할 수 있다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

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

ul = [[0] * m for _ in range(n)]
ur = [[0] * m for _ in range(n)]
dl = [[0] * m for _ in range(n)]
dr = [[0] * m for _ in range(n)]

for y in range(n):
    for x in range(m):
        if arr[y][x] != '1': continue

        ul[y][x] = (ul[y - 1][x - 1] + 1) if y > 0 and x > 0 else 1
        ur[y][x] = (ur[y - 1][x + 1] + 1) if y > 0 and x < m - 1 else 1

for y in range(n - 1, -1, -1):
    for x in range(m - 1, -1, -1):
        if arr[y][x] != '1': continue

        dl[y][x] = (dl[y + 1][x - 1] + 1) if y < n - 1 and x > 0 else 1
        dr[y][x] = (dr[y + 1][x + 1] + 1) if y < n - 1 and x < m - 1 else 1

res = 0
for y in range(n):
    for x in range(m):
        limit = min(ur[y][x], dr[y][x])
        for size in range(limit, res, -1):
            ny, nx = y, x + 2 * (size - 1)
            if nx >= m: continue
            if ul[ny][nx] >= size and dl[ny][nx] >= size:
                res = max(res, size)
                break

print(res)

[백준 / BOJ] 1700 멀티탭 스케줄링 (Python)

PRESSO_ — Sat, 28 Feb 2026 12:29:54 +0900

문제 링크

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

사용 알고리즘

그리디

풀이

한정된 수량의 플러그에 각 전기용품을 순서대로 사용해야 할 경우에서

플러그를 최소한으로 빼며 모든 전기용품을 사용하려면 몇 번 플러그를 빼야하는지 구하는 문제이다.

여기서 중요한 점은 각 전기용품을 순서대로 사용해야 하기 때문에 전기용품을 사용하는 순서에 따라 가중치를 주어야 한다는 점이다.

플러그를 빼야 할 경우(현재 멀티탭에 꽂혀있는 전기용품의 개수가 k 이상일 경우),

현재 멀티탭 안에 꽂혀있는 전기용품들의 가중치를 구한 뒤 가중치가 가장 낮은 전기용품을 빼면 된다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n, k = map(int, input().split())
arr = [*map(int, input().split())]

now = set()


def get_remove(idx):
    res = []

    # 현재 꽂혀있는 전기용품들의 이후 가중치를 구한다.
    for e in now:
        t = 0
        for i in range(idx + 1, k):
            if arr[i] != e: continue
            # 비트 연산을 통해 순서에 따른 가중치를 구한다.
            t |= (1 << (k - i))
        res.append((t, e))
    
    # 가중치 순으로 정렬
    res.sort()

    # 가중치가 가장 낮은 전기용품을 반환한다.
    return res[0][1]


res = 0
for i in range(k):
    # 이미 꽂혀있는 경우 무시
    if arr[i] in now: continue
    # 아직 빈 플러그가 있는 경우 무시
    if len(now) < n:
        now.add(arr[i])
        continue
    
    # 가중치가 가장 낮은 전기용품을 빼고 새로운 전기용품을 꼽는다.
    res += 1
    now.remove(get_remove(i))
    now.add(arr[i])

print(res)

[백준 / BOJ] 1029 그림 교환 (Python)

PRESSO_ — Wed, 25 Feb 2026 13:42:04 +0900

문제 링크

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

사용 알고리즘

DP
비트필드를 이용한 다이나믹 프로그래밍
그래프 이론

풀이

이 문제를 해결하기 위해 DP 배열에 저장해야 할 정보는 3가지이다.

현재 그림을 가지고 있는 사람: 다음 거래의 가격을 결정하기 위해 필요하다.
직전에 거래된 가격: 다음 거래의 가격이 직전 거래의 가격보다 크거나 같은지 확인하기 위해 필요하다.
지금까지 지나온 사람들: 이미 거래한 사람들에게 다시 거래하지 않기 위해 필요하다.

이 3가지 조건에 따라 그림을 가지고 있던 사람의 최대값이 달라지게 된다.

DP 배열 내의 각 정보들의 크기는 아래와 같이 잡는다.

현재 그림을 가지고 있는 사람: n명
직전에 거래된 가격: 10 (최대 가격이 10이기 때문에)
지금까지 지나온 사람들: 1 << n (비트필드를 이용해서 지금까지 지나온 사람들을 기록 / 사람 수가 n명이기 때문에 1 << n 사이즈의 비트필드 생성)

따라서, `dp[now][price][log] = 현재까지 그림을 가지고 있던 사람 수`로 두고 그래프를 탐색해서 조건에 맞는 경우 dp 배열과 정답을 갱신한다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n = int(input())
arr = [[*map(int, input())] for _ in range(n)]

dp = [[[0] * (1 << n) for _ in range(10)] for _ in range(n)]
dp[0][0][0] = 1
s, res = [(0, 0, 0)], 0
while s:
    now, price, log = s.pop()
    
    for nxt in range(n):
        n_price, n_log = arr[now][nxt], (log | (1 << now))

        if (
            now == nxt or
            price > n_price or
            (log & (1 << nxt)) or
            dp[nxt][n_price][n_log]
        ): continue

        dp[nxt][n_price][n_log] = dp[now][price][log] + 1
        res = max(res, dp[nxt][n_price][n_log])
        s.append((nxt, n_price, n_log))

print(res)

[백준 / BOJ] 1339 단어 수학 (Python)

PRESSO_ — Fri, 30 Jan 2026 18:36:18 +0900

문제 링크

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

사용 알고리즘

그리디

풀이

단어들에 등장하는 알파벳에 각각 숫자를 대입해서 반환된 값의 합의 최대를 구하는 문제이다.

이를 구하기 위해서는 등장하는 각 알파벳 별로 모든 단어에서 해당 알파벳이 위치한 자리가 큰 순서대로 숫자를 할당해주면 된다.

예제

입력

2
GCF
ACDEB

위의 예제에서 등장하는 알파벳은 (A, B, C, D, E, F, G)이다.

알파벳이 등장하는 자리에 따라 가중치를 더 크게 주어야 하기 때문에 모든 단어들에 0을 패딩해 자리수를 맞춰주자.

index	0	1	2	3	4
S[0]	0	0	G	C	F
S[1]	A	C	D	E	B

이와 같은 상태에서 자리수별로 가중치를 주게 된다면 아래 표와 같이 되고, 가중치가 높은 순서대로 숫자를 할당해주면 된다.

알파벳	가중치	할당된 숫자
A	10,000	9
C	1,010	8
D	100	7
G	100	6
E	10	5
B	1	4
F	1	3

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n = int(input())
words = [input().zfill(8) for _ in range(n)]

d = dict()
for w in words:
    for i in range(len(w)):
        if w[i] == '0': continue

        if w[i] not in d: d[w[i]] = 0
        d[w[i]] += 10 ** (8 - i - 1)

d = sorted([[x[0], x[1]] for x in d.items()], key=lambda x: x[1])
k = dict()
for i in range(9, 10 - len(d) - 1, -1):
    k[d.pop()[0]] = i

res = 0
for w in words:
    t = 0
    for c in w:
        if c not in k: continue
        t *= 10
        t += k[c]
    res += t

print(res)

[백준 / BOJ] 2602 돌다리 건너기 (Python)

PRESSO_ — Wed, 14 Jan 2026 16:57:42 +0900

문제 링크

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

사용 알고리즘

풀이

천사 or 악마, 현재 밟고 있는 위치, 현재 문자열이 두루마리의 몇 번째 문자열인지를 저장할 DP 배열을 만들어준다.

우선 DP 배열을 초기화하기 위해 두루마리의 맨 처음 문자열을 밟아준다.

s, devil, angel = input(), input(), input()
dp = [[[0] * len(s) for _ in range(len(devil))] for _ in range(2)]

for now in range(len(devil)):
    if devil[now] == s[0]: dp[0][now][0] = 1
    if angel[now] == s[0]: dp[1][now][0] = 1

그 후, 돌다리의 각 위치마다 두루마리의 2번째 문자부터 등장하는 모든 문자에 대해서

현재 밟고 있는 위치가 두루마리에 존재한다면 `반대 돌다리에서 과거에 밟은 위치의 등장 위치 - 1`를 현재에 더해준다.

for now in range(len(devil)):
    for where in range(1, len(s)):
        if devil[now] == s[where]:
            for before in range(now):
                dp[0][now][where] += dp[1][before][where - 1]
        if angel[now] == s[where]:
            for before in range(now):
                dp[1][now][where] += dp[0][before][where - 1]

마지막으로 각 돌다리에 대해 i번째 위치를 밟고 있을 경우 두루마리의 마지막이 될 수 있는 경우를 더해주면 된다.

res = 0
for i in range(len(devil)):
    res += dp[0][i][-1] + dp[1][i][-1]
print(res)

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

s, devil, angel = input(), input(), input()
dp = [[[0] * len(s) for _ in range(len(devil))] for _ in range(2)]

for now in range(len(devil)):
    if devil[now] == s[0]: dp[0][now][0] = 1
    if angel[now] == s[0]: dp[1][now][0] = 1

for now in range(len(devil)):
    for where in range(1, len(s)):
        if devil[now] == s[where]:
            for before in range(now):
                dp[0][now][where] += dp[1][before][where - 1]
        if angel[now] == s[where]:
            for before in range(now):
                dp[1][now][where] += dp[0][before][where - 1]

res = 0
for i in range(len(devil)):
    res += dp[0][i][-1] + dp[1][i][-1]
print(res)

[백준 / BOJ] 17845 수강 과목 (Python)

PRESSO_ — Wed, 14 Jan 2026 10:58:35 +0900

문제 링크

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

사용 알고리즘

풀이

자주 접할 수 있는 DP 문제이다.

공부 시간에 따른 최대 중요도를 저장하는 DP 배열을 만든 뒤,

각 과목별로 `max(현재 최대 중요도, 현재 공부 시간 - 해당 과목의 필요한 공부 시간 + 해당 과목을 공부했을 때 얻을 수 있는 중요도)`를 구하면 된다.

이 때 과목별로 현재 시간에 따른 중요도를 갱신하는 과정에서 `t ~ n + 1`로 반복하면 동일한 중요도가 더해질 수 있기 때문에 뒤에서부터(`n ~ t - 1`) 반복하는 것으로 해결할 수 있다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n, k = map(int, input().split())
sub = sorted(tuple(map(int, input().split())) for _ in range(k))

dp = [0] * (n + 1)
for i, t in sub:
    for j in range(n, t - 1, -1):
        dp[j] = max(dp[j], dp[j - t] + i)
print(dp[-1])

[백준 / BOJ] 1563 개근상 (Python)

PRESSO_ — Wed, 14 Jan 2026 10:29:05 +0900

문제 링크

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

사용 알고리즘

풀이

여러 방법으로 시도하다 도저히 풀리지 않아 다른 사람의 풀이를 보고 푼 문제이다.

나는 출석, 지각, 결석에 따른 경우의 수를 저장하는 배열을 사용하려 했지만 구현 시 현재 출석했을 때 결석의 수를 초기화할 수 없기 때문에 잘못된 방식으로 접근했다.

이 문제를 해결하기 위해 만들어야 할 DP 배열은 i번째 날에 지각, 결석한 횟수에 따른 경우의 수를 저장하는 배열이다.

▶︎ `dp[학기의 날짜 수(= n + 1)][가능한 지각 횟수(= 2)][가능한 결석 횟수(= 3)]`

위와 같은 DP 배열을 만들면 현재 날짜의 지각, 결석 횟수에 따른 경우의 수를 저장할 수 있다.

현재 날짜의 지각, 결석 횟수에 따라 아래와 같은 경우가 나올 수 있다.

지각 0 & 결석 0
지각 0 & 결석 1
지각 0 & 결석 2
지각 1 & 결석 0
지각 1 & 결석 1
지각 1 & 결석 2

지각 0 & 결석 0

결석은 현재 날짜에 출석을 하면 초기화된다.

지각을 한번도 하지 않았고 결석도 한번도 하지 않았다면 오늘 출석을 했다는 뜻이다.

따라서, 지각을 한번도 하지 않았고 결석도 한번도 하지 않았다면 i - 1번째 날짜의 지각을 하지 않았을 경우의 수를 모두 더해주면 된다.

▶︎ `dp[i][0][0] = sum(dp[i - 1][0])`

지각 0 & 결석 1

현재 날짜에 결석을 한 경우이다.

지각을 한번도 하지 않았고 현재 날짜에 결석을 했다면 전날 지각을 한번도 하지 않았고 출석한 경우의 수를 그대로 가져온다.

▶︎ `dp[i][0][1] = dp[i - 1][0][0]`

지각 0 & 결석 2

두번 연속으로 결석을 한 경우이다.

지각을 한번도 하지 않았고 전일 결석 & 현재 날짜에 결석을 했다면 전날 지각을 한번도 하지 않았고 결석한 경우의 수를 그대로 가져온다.

▶︎ `dp[i][0][2] = dp[i - 1][0][1]`

지각 1 & 결석 0

현재까지 한 번 지각했고 결석을 하지 않은 경우이다.

마찬가지로 결석은 현재 날짜에 출석을 하면 초기화되기 때문에 0번 지각했을 경우의 모든 경우의 수와 1번 지각했을 경우의 모든 경우의 수를 더해주면 된다.

▶︎ `dp[i][1][0] = sum(dp[i - 1][0]) + sum(dp[i - 1][1]`

지각 1 & 결석 1, 지각 1 & 결석 2

이 경우에는 지각 0 & 결석 1, 지각 0 & 결석 2와 동일하게 이전까지 1번 지각하고 각각 0, 1번 결석한 경우를 그대로 가져온다.

▶︎ `dp[i][1][1], dp[i][i][2] = dp[i - 1][1][0], dp[i - 1][1][1]`

최종적으로 모든 경우의 수를 구하기 위해선 0번 지각했을 때 경우의 수의 합과 1번 지각했을 때 경우의 수의 합을 더해주면 된다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

MOD = 1000000

n = int(input())
dp = [[[0] * 3 for _ in range(2)] for _ in range(n + 1)]
dp[1][0][0], dp[1][1][0], dp[1][0][1] = 1, 1, 1

for i in range(2, n + 1):
    dp[i][0][0] = sum(dp[i - 1][0]) % MOD
    dp[i][0][1] = dp[i - 1][0][0] % MOD
    dp[i][0][2] = dp[i - 1][0][1] % MOD
    dp[i][1][0] = sum(dp[i - 1][0]) % MOD + sum(dp[i - 1][1]) % MOD
    dp[i][1][1] = dp[i - 1][1][0] % MOD
    dp[i][1][2] = dp[i - 1][1][1] % MOD

print((sum(dp[-1][0]) + sum(dp[-1][1])) % MOD)

[백준 / BOJ] 2229 조짜기 (Python)

PRESSO_ — Tue, 13 Jan 2026 15:25:46 +0900

문제 링크

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

사용 알고리즘

풀이

문제를 풀어서 설명하면 연속된 학생들끼리 묶어서 조를 구성할 경우, 각 조들의 잘 짜여진 정도의 합의 최댓값을 구하는 문제이다.

따라서, 각 학생별로 해당 학생까지 각 조들의 잘 짜여진 정도의 합의 최댓값을 저장하는 dp 배열이 필요하다.

▶︎ `dp[i] = dp[i]까지 각 조들의 잘 짜여진 정도의 합의 최댓값`

그리고 i번 학생까지 조가 잘 짜여진 정도의 합을 알기 위해선,

기존에 구했던 0 ~ i번 학생(j라고 가정)에서의 조가 잘 짜여진 정도의 합에

`max(i번 학생의 점수, j번 학생의 점수) - min(i번 학생의 점수, j번 학생의 점수)`를 더했을 때 최대가 되는 값을 구하면 된다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n, students = int(input()), [int(x) for x in input().split()]

dp = [0] * (n + 1)
for i in range(1, n + 1):
    for j in range(i, 0, -1):
        minimal = min(students[i - 1], students[j - 1])
        maximum = max(students[i - 1], students[j - 1])
        dp[i] = max(
            dp[i],
            dp[j - 1] + maximum - minimal
        )
print(dp[-1])

[백준 / BOJ] 11058 크리보드 (Python)

PRESSO_ — Tue, 13 Jan 2026 10:20:54 +0900

문제 링크

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

사용 알고리즘

풀이

dp 배열의 각 인덱스를 현재 버튼을 i개 눌렀을 때 화면에 출력된 A의 최대 개수로 가정한다.

▶︎ `dp[i] = i번 버튼을 눌렀을 때 화면에 출력된 A의 최대 개수`

dp 배열의 초기값으로는 단순이 A만 눌렀을 때 화면에 출력된 A의 개수로 설정해두고,

각 위치에서 Ctrl-A, Ctrl-C, Ctrl-V를 했을 경우(= `i + 2`) 나올 수 있는 A의 개수로 dp 배열을 갱신해주면 된다.

코드

import sys, os, io, atexit

input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
atexit.register(lambda: os.write(1, stdout.getvalue()))

n = int(input())

dp = [i for i in range(n + 1)]
for i in range(4, n + 1):
    for j in range(i + 2, n + 1):
        dp[j] = max(dp[j], dp[i - 1] * (j - i))
print(dp[-1])