소민's Blog

[백준][DP][카데인 알고리즘] 연속합

박소민 — Thu, 19 Feb 2026 21:07:04 +0900

연속합

첫 풀이
- 오류 원인
- if i == 0:
  dp[i] = max(0, numbers[i])
- -5 -2 -3 일때 max(dp)에서 dp[0]=0 이 채택되면 없는 값이 선택 되는 것

n = int(input())
numbers = list(map(int, input().split()))
dp = numbers[:]
for i in range(n):
    if i == 0:
        dp[i] = max(0, numbers[i])
        continue
    dp[i] = max(numbers[i], dp[i-1]+numbers[i])

print(max(dp))

내 풀이
- 해당 위치값부터 시작하거나
- 이전값에서 해당위치값을 더하거나
- 2가지 경우 중 선택

n = int(input())
numbers = list(map(int, input().split()))
dp = numbers[:]
for i in range(1, n):
    dp[i] = max(numbers[i], dp[i-1]+numbers[i])

print(max(dp))

[백준][DP] RGB 거리

박소민 — Mon, 16 Feb 2026 17:15:27 +0900

RGB거리

각 col, row가 어떤 값인지 주의해서 넣을 것

n = int(input())
graph = [list(map(int, input().split())) for _ in range(n)]
dp = [[float('inf') for _ in range(3)] for _ in range(n)]

for i in range(n):
    for j in range(3):
        if i == 0:
            dp[i][j] = graph[i][j]
            continue
        for k in range(3):
            if j == k:
                continue
            dp[i][j] = min(dp[i][j], dp[i-1][k]+graph[i][j])

print(min(dp[n-1]))

[백준][DP] 설탕 배달

박소민 — Mon, 16 Feb 2026 16:48:41 +0900

설탕 배달

초기화할때 n이 초기화하는 값보다 작은 경우를 고려해줘야함

n=int(input())
dp=[float('inf') for _ in range(n+1)]
if n>=3:
    dp[3]=1
if n>=5:
    dp[5]=1

for i in range(5, n+1):
    dp[i]=min(dp[i],min(dp[i-3],dp[i-5])+1)

if dp[n]==float('inf'):
    print(-1)
else:
    print(dp[n])

[프로그래머스][그리디] 큰 수 만들기

박소민 — Tue, 10 Feb 2026 00:01:51 +0900

[프로그래머스][그리디] 큰 수 만들기


def solution(number, k):
    answer = []
    for num in number:
        while answer and k>0 and answer[-1]<num:
            answer.pop()
            k-=1
        answer.append(num)
    
    if k>0:
        answer=answer[:-k]
    
    return ''.join(answer)

풀이
1. 숫자를 왼쪽부터 순차적으로 탐색하며 스택에 쌓는다.
2. 새로운 숫자를 넣을 때, 스택에 나보다 작은 숫자가 있다면 그 숫자를 제거하고(k 감소) 내가 그 자리를 대신한다.
3. 반복: 나보다 큰 숫자를 만나거나 k가 0이 될 때까지 앞의 숫자들을 연쇄적으로 지운다.
4. 예외: 전체 탐색 후에도 k가 남았다면, 뒤에서부터 남은 k만큼 잘라낸다 (이미 내림차순인 경우).
시간 복잡도: O(n)인 이유
• 분할 상환 분석(Amortized Analysis)
: for문 안에 while문이 있어 O(n^2)처럼 보일 수 있으나,
모든 숫자는 스택에 딱 한 번 들어가고(Push), 최대 한 번 나간다(Pop).
• -> 전체 연산 횟수는 최대 2n을 넘지 않음
O(n^2) 이러면 매번 전체를 돌아야함
하지만 이 로직은 앞에서 제거하면 다시 돌지 않음
각 값은 들어오고/나가고 2번의기회뿐 -> O(2n)

[프로그래머스] 가장 가까운 같은 글자

박소민 — Tue, 20 Jan 2026 23:06:32 +0900

가장 가까운 같은 글자

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

내 풀이
- 주의할 점
  - reverse.index(a)
  - a가 index를 시도하려는 리스트안에 없으면 ValueError 발생
  - a가 있는지 검토 후 진행

def solution(s):
    answer = []
    for idx, a in enumerate(s):
        reverse = list(reversed(s[:idx]))
        if a in reverse:
            i = reverse.index(a)
            answer.append(i + 1)
        else:
            answer.append(-1)
    return answer

[프로그래머스][구현] 서버 증설 횟수

박소민 — Fri, 3 Oct 2025 20:21:32 +0900

서버 증설 횟수

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

내 풀이
- 이미 서버 1개가 돌고 있으므로 3명 부터 → 1개 추가 증설
- 해당 인원을 위해 필요한 서버 수 : need (기본 1개 제외하고)
- 현재 이용가능한 서버 수 = len(servers)
- 현재 추가로 증설해야 하는 서버 수: plus
- 주의
  - 0~1 시 → idx =0
  - 10~15시 사용가능한 서버 → idx=14 (14~15시) 까지만 이용 가능
  - 그러므로 bisect으로 같은 값까지 포함해서 자르게 하려면 servers에 idx값에 맞춰 넣어줘야함
  - => idx+k-1 (10+5-1 =14)

from bisect import bisect_left

def solution(players, m, k):
    answer=0
    servers=[]
    
    for idx, player in enumerate(players):
        i=bisect_left(servers, idx)
        if i!=0:
            servers=servers[i:]
        
        if player<m:
            continue
            
        need=player//m
        if need>len(servers):
            plus=need-len(servers)
            answer+=plus 
            servers+=[idx+k-1 for _ in range(plus)]
        
    return answer

[백준][이분탐색] 1654.랜선 자르기

박소민 — Fri, 26 Sep 2025 00:32:24 +0900

1654.랜선 자르기

내 풀이
- 랜선 길이를 mid로 잡고
- 만들어질 수 있는 갯수 체크
- 필요한 n개보다 많거나 같으면 -> 현재 랜선 길이 mid가 너무 짧은 것
  - max값으로 저장 후
  - l= mid+1
- 필요한 갯수보다 적으면 -> 현재 랜선길이 mid가 너무 긴 것
  - r=mid-1
- 주의
  - 처음 랜선길이 l=0 으로 잡으면 zeroDivizonError 날 수 있음
  - l=1 로 잡아야함

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

l = 0
r = max(lans)

ans = 0
while l <= r:
    mid = (l+r)//2

    cnt = 0
    for lan in lans:
        cnt += (lan//mid)

    if cnt >= n:
        ans = max(ans, mid)
        l = mid+1
    else:
        r = mid-1

print(ans)

[백준][다익스트라] 1753. 최단 경로

박소민 — Fri, 26 Sep 2025 00:06:11 +0900

1753. 최단 경로

내 풀이
- 양수의 가중치를 가지는 방향 그래프 -> 다익스트라

from collections import deque, defaultdict
import heapq

v, e = map(int, input().split())
point = int(input())
graph = defaultdict(list)

for _ in range(e):
    start, end, val = map(int, input().split())
    graph[start].append((end, val))

dist = [float('inf') for _ in range(v+1)]

def dijkstra(start):
    queue = []
    heapq.heappush(queue, (0, start))
    dist[start] = 0

    while queue:
        cur_dist, cur = heapq.heappop(queue)

        for nxt, val in graph[cur]:
            if dist[nxt] <= dist[cur]+val:
                continue
            dist[nxt] = dist[cur]+val
            heapq.heappush(queue, (dist[nxt], nxt))


dijkstra(point)
for d in dist[1:]: #첫번째는 0이므로 제외
    if d == float('inf'):
        print("INF")
    else:
        print(d)

가장 기본 구조

import heapq

v, e = map(int, input().split())
point = int(input())

graph = [[] for _ in range(v+1)]  # 1번~v번 노드 사용

for _ in range(e):
    start, end, val = map(int, input().split())
    graph[start].append((end, val))

dist = [float('inf')] * (v+1)
dist[point] = 0

queue = []
heapq.heappush(queue, (0, point))

while queue:
    cur_dist, cur = heapq.heappop(queue)
    
    # 이미 더 짧은 거리로 처리한 경우 무시
    if cur_dist > dist[cur]:
        continue

    for nxt, val in graph[cur]:
        if dist[nxt] > dist[cur] + val:
            dist[nxt] = dist[cur] + val
            heapq.heappush(queue, (dist[nxt], nxt))

for d in dist[1:]:
    print("INF" if d == float('inf') else d)

[프로그래머스][Set][교집합] 비밀 코드 해독

박소민 — Wed, 24 Sep 2025 21:06:15 +0900

비밀 코드 해독

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이
- 제한
  - 10 ≤ n ≤ 30
  - 1 ≤ (q의 길이 = m) ≤ 10
- 30까지의 숫자 중 5개를 고르는 조합 하나씩 돌면서
- 모든 쿼리랑 교집합 했을때의 갯수가 ans 랑 동일해야함
  - 시간복잡도
    - 30C5 := (24300000 / 120) =202500
    - q 최대 10
    - 교집합 5
    - = 202500 * 10 * 5
- 교집합 갯수가 다르면 out

from itertools import combinations

def solution(n, q, ans):
    answer = 0
    
    for comb in combinations(range(1,n+1),5):
        for i, query in enumerate(q):
            if len(set(comb)&set(query))!=ans[i]:
                break
        else:
             answer+=1  
                
    return answer

[백준][DP] 2839. 설탕 배달

박소민 — Mon, 22 Sep 2025 22:17:55 +0900

2839. 설탕 배달

내 풀이
- dp[i] = i kg을 만들 때 필요한 최소 봉지 수.
- 기본값: dp[3] = 1, dp[5] = 1
- 점화식 구현 방식
  - i-3, i-5 둘 다 불가능(=0) → dp[i]도 불가능(=0)
  - 두 값이 다 가능하면 → dp[i] = min(dp[i-3], dp[i-5]) + 1
  - 한쪽만 가능하면 → 그쪽 값 + 1
- 즉, 불가능한 값(0)은 min 비교에 넣으면 안 됨.

n = int(input())
dp = [0 for _ in range(max(6, n+1))]
dp[3] = 1
dp[5] = 1
for i in range(6, n+1):
    if dp[i-3] == 0 and dp[i-5] == 0:
        continue
    if dp[i-3] != 0 and dp[i-5] != 0:
        dp[i] = min(dp[i-3], dp[i-5])+1
        continue
    if dp[i-3] == 0:
        dp[i] = dp[i-5]+1
    elif dp[i-5] == 0:
        dp[i] = dp[i-3]+1

print(dp[n] if dp[n] != 0 else -1)

다른 사람 풀이
- 5로 나뉘는게 무조건 최소 봉지
- 5로 안되면 모두 3kg 봉지라는 가정하에 sugar-=3, bag+=1

sugar = int(input())

bag = 0
while sugar >= 0 :
    if sugar % 5 == 0 :  # 5의 배수이면
        bag += (sugar // 5)  # 5로 나눈 몫을 구해야 정수가 됨
        print(bag)
        break
    sugar -= 3  
    bag += 1  # 5의 배수가 될 때까지 설탕-3, 봉지+1
else :
    print(-1)

소민's Blog

[백준][DP][카데인 알고리즘] 연속합

[백준][DP] RGB 거리

[백준][DP] 설탕 배달﻿

[프로그래머스][그리디] 큰 수 만들기

[프로그래머스] 가장 가까운 같은 글자

[프로그래머스][구현] 서버 증설 횟수

[백준][이분탐색] 1654.랜선 자르기

[백준][다익스트라] 1753. 최단 경로

[프로그래머스][Set][교집합] 비밀 코드 해독

[백준][DP] 2839. 설탕 배달

[백준][DP] 설탕 배달