test PR

[learntosurf]

🌱WIL

• 유형별로 풀이법을 정리하고 복습하는게 중요한 것 같다. 스터디 과제 PR 올리는 걸 미루다가 깜빡하게 되는데 빼먹지 말고 올리기!

🚀주간 목표 문제 수: 5개

푼 문제

• 백준 #10026. 적록색약: 그래프 / 골드5
• 백준 #4963. 섬의 개수: 그래프 / 실버2
• 백준 #14430. 자원 캐기: DP / 실버2
• 백준 #2503. 숫자 야구: 구현 / 실버3
• 백준 #2342. Dance Dance Revolution: DP / 골드3
• 백준 #2293. 동전1: DP / 골드4

---

백준 #10026. 적록색약: DFS/BFS / 골드5

정리한 링크: 바로가기

🚩플로우 (선택)

1. $N$을 입력받고 $N$ x $N$ 크기의 그리드를 저장한다.
2. BFS/DFS를 이용하여 같은 색의 영역을 찾는다.
   • 적록색약이 아닌 경우와 적록색약인 경우를 각각 계산해야 한다.
   • 모든 칸을 훑어보면서 아직 방문하지 않은 색이 있다면, 그 칸을 시작점으로 탐색을 시작한다.
   • 탐색하면서 상하좌우로 같은 색인 곳을 찾아가고, 방문 표시를 남긴다. 이게 하나의 구역이 된다.
3. 적록색약이 아닌 사람 기준으로 구역 탐색을 진행한다.
4. 적록색약 탐색을 위해 그리드를 변경한다.
5. 적록색약 기준으로 구역 탐색을 진행한다.

🚩제출한 코드

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

N = int(input().strip())
grid = [list(input().strip()) for _ in range(N)]

# 방향 벡터 
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

def bfs(x, y, color, visited, grid):
    queue = deque([(x, y)]) # 큐 초기화 및 시작점 추가 
    visited[x][y] = True # 방문 처리 
    
    while queue:
        x, y = queue.popleft() # 큐에서 하나를 꺼냄
        for i in range(4): # 상하좌우 탐색
            nx, ny = x + dx[i], y + dy[i]
            # 새로운 위치가 범위 내에 있고, 방문하지 않았으며, 같은 색이면 탐색 진행 
            if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny]:
                if grid[nx][ny] == color:
                    visited  [nx][ny] = True # 방문 처리
                    queue.append((nx, ny)) # 큐에 추가 

def count_regions(grid, is_color_blind):
    visited = [[False] * N for _ in range(N)]
    count = 0

    for i in range(N):
        for j in range(N):
            if not visited[i][j]:  # 방문하지 않은 경우 BFS 탐색 시작
                count += 1
                color = grid[i][j]

                # 적록색약 모드라면 R과 G를 동일하게 처리
                if is_color_blind and color in "RG":
                    bfs(i, j, "R", visited, grid)
                else:
                    bfs(i, j, color, visited, grid)
    
    return count

# 적록색약이 아닌 경우 
normal_count = count_regions(grid, is_color_blind=False)

# 적록색약인 경우 (R과 G를 동일하게 처리한 grid 생성)
 for i in range(N):
   for j in range(N):
        if grid[i][j] == 'G':
            grid[i][j] = 'R'
                   
color_blind_count = count_regions(grid, is_color_blind=True)
print(normal_count, color_blind_count)

💡TIL

• 2차원 배열의 상하좌우 인접 탐색은 대표적으로 BFS/DFS를 활용해서 해결할 수 있다.
• BFS/DFS에서 항상 두 조건을 확인한다.
  • (1) 주어진 배열 범위를 벗어나지는 않았는가?
  • (2) 이미 방문된 곳은 아닌가? 현재 탐색중인 구역과 같은 색인가?

백준 #4963. 섬의 개수: DFS/BFS / 실버2

정리한 링크: 바로가기

🚩플로우 (선택)

1. 입력을 받아서 2차원 리스트(지도)로 저장한다.
2. 모든 칸을 탐색하며 1(땅)을 찾으면, DFS 또는 BFS를 사용하여 연결된 모든 땅을 방문 처리한다.
   • DFS(재귀)를 사용하여 연결된 땅을 모두 탐색한다.
     • 인접한 노드를 큐에 넣기 전에 (1)지도 밖으로 벗어나지는 않았는지, (2)바다이거나 이미 방문된 곳은 아닌지 조건을 확인해야 한다.
     • visited 배열 없이 1→0으로 바꾸어 탐색을 처리 할 수 있다
   • 또는 BFS(큐)를 사용하여 연결된 땅을 큐에 넣고 탐색한다.
3. 새로운 섬을 찾을 때마다 카운트를 증가시킨다.
4. 여러개의 케이스를 처리하고, (0, 0) 입력이 들어오면 종료한다.

🚩제출한 코드

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

# 8방향 (상, 하, 좌, 우, 대각선 4개)
dx = [-1, 1, 0, 0, -1, -1, 1, 1]
dy = [0, 0, -1, 1, -1, 1, -1, 1]

def bfs(x, y, graph, w, h):
    queue = deque([(x, y)])
    graph[y][x] = 0  # 방문 처리 (1 → 0 변경)

    while queue: # 큐가 빌 때까지 반복
        cx, cy = queue.popleft() # 현재 좌표 꺼내기 
        for i in range(8):  # 8방향 탐색
            nx, ny = cx + dx[i], cy + dy[i] # 새로운 좌표 계산
            if 0 <= nx < w and 0 <= ny < h and graph[ny][nx] == 1:
                graph[ny][nx] = 0  # 방문 처리
                queue.append((nx, ny)) # 큐에 추가 (다음에 탐색할 곳)
 
while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0:
        break  # 종료 조건
    island = [list(map(int, input().split())) for _ in range(h)]

    count = 0 # 섬의 개수 
    for y in range(h):
        for x in range(w):
            if island[y][x] == 1:  # 새로운 섬 발견
                count += 1
                bfs(x, y, island, w, h) # BFS 실행
    
    print(count)

💡TIL

• 8방향 탐색

  • 방향벡터 (행과 열 관점에서 좌표를 이동하는 방식)

    dx = [-1, 1, 0, 0, -1, -1, 1, 1]  # X(가로) 방향 이동
    dy = [0, 0, -1, 1, -1, 1, -1, 1]  # Y(세로) 방향 이동
    

    방향	dx (열 이동)	dy (행 이동)
    상(위)	-1	0
    하(아래)	1	0
    좌(왼쪽)	0	-1
    우(오른쪽)	0	1
    좌상(왼쪽 위)	-1	-1
    우상(오른쪽 위)	-1	1
    좌하(왼쪽 아래)	1	-1
    우하(오른쪽 아래)	1	1

    • y(행, 세로 방향): 아래로 갈수록 +1, 위로 갈수록 -1
    • x(열, 가로 방향): 오른쪽으로 갈수록 +1, 왼쪽으로 갈수록 -1

  • dx[i], dy[i]를 사용하여 반복문으로 탐색하면 코드를 단순하게 만들 수 있다.

• queue = deque([(x, y)]), queue.append((nx, ny)): 리스트 안에 튜플 처리해서 추가해주어야 한다.

백준 #14430. 자원 캐기: DP / 실버2

정리한 링크: 바로가기

🚩플로우 (선택)

1. DP 테이블을 정의한다.
   • dp[i][j]: (i, j)까지 도달했을 때 최대 자원 개수
2. 점화식을 유도한다.
   • (i, j)에 도착했을 때 가능한 두 가지 경로는 다음과 같다.
     • (i-1, j)에서 아래로 내려온 경우
     • (i, j-1)에서 오른쪽으로 이동한 경우
   • 따라서, DP 점화식은 dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid([i][j])이다.
   • 단, dp[0][j]와 dp[i][0]은 각각 첫 행과 첫 열이므로 초기화가 필요하다.
3. 초기 조건을 설정한다.
   • dp[0][0] = grid[0][0]
   • 첫 번째 행: dp[0][j] = dp[0][j-1] + grid[0][j]
   • 첫 번째 열: dp[i][0] = dp[i-1][0] + grid[i][0]

🚩제출한 코드

import sys 
input = sys.stdin.readline

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

dp = [[0] * M for _ in range(N)]
dp[0][0] = grid[0][0]

def max_resources(N, M, grid):
    # 첫 번째 행 채우기
    for j in range(1, M):
        dp[0][j] = dp[0][j-1] + grid[0][j]

    # 첫 번째 열 채우기
    for i in range(1, N):
        dp[i][0] = dp[i-1][0] + grid[i][0]

    # DP 테이블 채우기
    for i in range(1, N):
        for j in range(1, M):
            dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j]

    return dp[N-1][M-1]

print(max_resources(N, M, grid))

💡TIL

• DP를 이용하면 빠르게 해결할 수 있다.
• 그리디나 BFS/DFS로는 접근하기 어렵다. 최적해를 구하기 위한 누적 합을 관리하는 방식이 적절하다.

백준 #2503. 숫자 야구: 구현 / 실버3

정리한 링크: 바로가기

🚩플로우 (선택)

1. 1~9중 서로 다른 3개의 숫자로 이루어진 모든 경우의 수를 생성한다.
2. 각 숫자에 대해 질문을 검증한다.
   • 각 후보 숫자가 모든 질문의 스트라이크와 볼 개수 조건을 만족하는지 확인한다.
3. 모든 질문을 만족하는 경우만 세어 경우의 개수를 출력한다.

🚩제출한 코드

import sys 
input = sys.stdin.readline
from itertools import permutations

N = int(input().strip()) # 질문 횟수 
questions = [list(map(int, input().split())) for _ in range(N)] # 질문 리스트

# 1부터 9까지의 숫자 중 3개를 뽑는 순열
nums = list(permutations(range(1,10), 3)) 
cnt = 0 # 가능한 경우의 수

# 두 수를 비교하여 스트라이크와 볼을 반환
def strike_and_ball(num1, num2):
    strike = sum(a == b for a, b in zip(num1, num2))
    ball = sum(a in num2 for a in num1) - strike
    return strike, ball 
    
for num in nums:
    num_str = ''.join(map(str, num)) # 순열을 문자열로 변환
    valid = True # 가능한 숫자인지 판별
    
    for q_num, q_strike, q_ball in questions:
        q_str = str(q_num) # 입력된 숫자도 문자열 변환 
        strike, ball = strike_and_ball(num_str, q_str)
        if strike != q_strike or ball != q_ball:
            valid = False
            break  # 하나라도 불가능하면 더 볼 필요 없음
    
    if valid:
        cnt += 1

print(cnt)

💡TIL

• permutations(range(1,10), 3): 1~9까지 서로 다른 숫자 3개를 뽑는 순열(Permutation)

  (1, 2, 3), (1, 2, 4), ..., (9, 8, 7)

• 스트라이크와 볼을 계산하는 함수

  def strike_and_ball(num1, num2):
      strike = sum(a == b for a, b in zip(num1, num2))
      ball = sum(a in num2 for a in num1) - strike
      return strike, ball 

  • 스트라이크 계산: sum(a == b for a, b in zip(num1, num2))

    • zip(num1, num2): 두 숫자를 자리별로 묶어서 비교한다.
    • 같은 자리(index)에서 숫자가 같은 경우만 True이다. → 1로 계산한다.
    • sum()을 사용하여 True 개수를 구한다.

    num1 = (3, 2, 4)  # 후보 숫자
    num2 = (4, 2, 9)  # 질문 숫자
    
    zip(num1, num2)  # [(3,4), (2,2), (4,9)]
    strike = sum(a == b for a, b in zip(num1, num2))  
    # → False(0), True(1), False(0)  -> sum(0, 1, 0) = 1
    
    print(strike)  # 출력: 1

  • 볼 계산: sum(a in num2 for a in num1) - strike

    • num1의 각 숫자가 num2에 포함되어 있는지를 체크한다. (순서는 무관하다.)
    • 포함되어 있다면 True로 1로 계산한다. 단, 스트라이크의 개수는 빼주어야 한다.

    num1 = (3, 2, 4)  # 후보 숫자
    num2 = (4, 2, 9)  # 질문 숫자
    
    # 1. `sum(a in num2 for a in num1)`
    #    - 3은 num2(4,2,9)에 없음 → False(0)
    #    - 2는 num2(4,2,9)에 있음 → True(1)
    #    - 4는 num2(4,2,9)에 있음 → True(1)
    #    → 총합: 0 + 1 + 1 = 2 (strike 포함)
    
    # 2. `strike` 값 빼기
    strike = 1  # 위에서 구한 값
    ball = 2 - 1  # 총 2개 중 1개는 strike였으므로 제외
    print(ball)  # 출력: 1

• 결과(strike, ball)가 질문의 q_strike, q_ball과 다르면 불가능한 숫자이므로 valid=False로 설정하고 break한다.

백준 #2342. Dance Dance Revolution: DP / 골드3

정리한 링크: (바로가기)

🚩제출한 코드

import sys 
input = sys.stdin.readline

steps = list(map(int, input().split()))
if steps: 
    steps.pop()  # 마지막 0 제거

# dp 테이블
INF = float('inf') # 무한대 값 
dp = [[INF]*5 for _ in range(5)]
dp[0][0] = 0

def move_power(start, end):
    if start == 0: # 중앙에서 다른 곳으로 이동하는 경우 
        return 2
    if start == end: # 같은 지점을 연속해서 밟는 경우 
        return 1 
    if abs(start - end) == 2: # 반대편으로 이동하는 경우
        return 4 
    return 3 # 인접한 지점으로 이동하는 경우

for step in steps:
    new_dp = [[INF]*5 for _ in range(5)] # 새로운 dp 테이블
    
    for left in range(5):
        for right in range(5):
            if dp[left][right] == INF:
                continue 
            
            current_power = dp[left][right] # 현재 위치의 힘의 소모량
            
            # 왼발을 움직이는 경우 (오른발이 step에 있으면 안 됨)
            if step != right:
                new_dp[step][right] = min(new_dp[step][right], current_power + move_power(left, step))

            # 오른발을 움직이는 경우 (왼발이 step에 있으면 안 됨)
            if step != left:
                new_dp[left][step] = min(new_dp[left][step], current_power + move_power(right, step))
    
    dp = new_dp # dp 테이블 업데이트

print(min(min(row) for row in dp)) 

백준 #2293. 동전1: DP / 골드4

🚩제출한 코드

import sys 
input = sys.stdin.readline

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

dp = [0] * (k + 1)
dp[0] = 1 # 0원을 만드는 경우의 수는 1 (아무 동전도 사용하지 않는 경우)

for coin in coins: 
    for j in range(coin, k+1):
        dp[j] += dp[j - coin] # 점화식

print(dp[k])

[github-actions]

2025-04 챌린지 진행 상황

사용자	챌린지 유형	문제 수	달성 여부
Mingguriguri	그래프	0	❌
Mingguriguri	DP	5	✅
zaqquum	그래프	0	❌
zaqquum	DP	2	❌
learntosurf	그래프	0	❌
learntosurf	DP	3	❌

[github-actions]

2025-04 챌린지 진행 상황

사용자	챌린지 유형	문제 수	달성 여부
Mingguriguri	그래프	0	❌
Mingguriguri	DP	5	✅
zaqquum	그래프	0	❌
zaqquum	DP	2	❌
learntosurf	그래프	2	❌
learntosurf	DP	3	❌