Merge branch 'main' into minjeong3

Author: Mingguriguri

.github/workflows/update_challenge_progress.yml

@@ -37,10 +37,9 @@ jobs:
           cd _MonthlyChallenges
           git config --global user.name "${{ secrets.GIT_USER_NAME }}"
           git config --global user.email "${{ secrets.GIT_USER_EMAIL }}"
+          git pull origin main
           git add scoreboard.json DASHBOARD.md HISTORY.md
           git commit -m "Update challenge progress dashboard" || echo "No changes to commit"
-          cd ..
-          git remote set-url origin https://x-access-token:${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/AlgorithmStudy-Allumbus/codingtest_algorithm_study.git
           git push origin ${{ github.head_ref }}
 
       - name: Post PR Comment with progress

Hongjoo/백준/로봇조종하기.py

@@ -10,7 +10,6 @@
 for n in range(N) :
   fields.append(list(map(int, input().split())))
 
-# print(fields)
 # 2. dp 테이블 초기화 
 dp = [[0 for _ in range(M)] for k in range(N)]
 left2right = [[0 for _ in range(M)] for k in range(N)]

Hongjoo/백준/수열.py

@@ -0,0 +1,31 @@
+"""
+# slide window , 투 포인터
+-연속된 날짜의 온도 합 중 최대값 출력 = goal
+- sum(temp[s:e]) 같은 한번씩 슬라이딩으로 합을 구하면 시간 초과 발생
+- window 범위 내 start 와 end 포인트 값을 빼고, 더하는 식으로 전체 합 구하기
+# flow
+1. temp 리스트 입력 받기
+-window size =k , N  : 날짜
+2. window 범위에 해당하는 리스트 합 중 최대값 구하기
+next_window = 이전 window - 앞 + 뒤
+=> sliding winodw을 통해 window 내 맨앞과 맨 뒤 값만 구해서 더하고 빼면 범위내 총합 구할 수 있다.
+
+"""
+import sys
+input = sys.stdin.readline
+#0. 전체 일수 = N , 연속 일수= K ,
+N , k = map(int,input().split())
+temp = list(map(int, input().split()))
+
+# 1. 첫 window 범위 초기화 
+sum_tmp = sum(temp[0:k]) # 초기 window 내 리스트의 합
+max_sum = sum_tmp # 최대값을 window 합 초기값으로 설정
+# 2. 투 포인터 (s,e)을 이동하여 window 범위 합 구하기 
+# e :새로운 window 범위에 들어가는 값
+# s :새로운 window 범위에서 빠지는 값 
+for e in range(k, N):
+  s = e-k # 0 n-k
+  sum_tmp = sum_tmp - temp[s] + temp[e] # 새로운 window 범위 내의 합
+  max_sum = max(max_sum , sum_tmp) # 
+
+print(max_sum)

Hongjoo/백준/안전영역.py

@@ -0,0 +1,31 @@
+"""
+#피보나치 비스무리한수열 / 실버 5
+https://www.acmicpc.net/problem/14495
+- 조건 : 1< n <=116
+
+# 문제 유형 : DP
+1. 입력
+2. dp 생성
+dp[1<idx <=n] = [1,1,1...f(n)]
+-초기화 : dp[1]=dp[2]=dp[3] = 1 
+
+3. 점화식 
+f(n) = f(n-1) + f(n-3)
+- dp에 저장하기
+- dp에 있으면 호출, 없으면 계산 & dp에 업데이트 
+"""
+#1. 입력 변수 저장
+N = int(input())
+#2. dp 생성 & 초기화
+dp = [ 0 for _ in range(116+1)]
+
+
+#3. 점화식 
+for i in range(0,N+1) :
+  if i in [0,1,2,3] :
+    dp[i] = 1
+  elif dp[i] == 0 : # i>=4, dp에 없으면 -> 업데이트
+   
+    dp[i] = dp[i-1] + dp[i-3]
+
+print(dp[N])

Hongjoo/백준/피보나치비스무리한수열.py

@@ -1,68 +1,59 @@
 from collections import deque
 
-# 2차원 배열을 이용한 bfs 구현
-def bfs(x, y):
+dx = [-1, 1, 0, 0]
+dy = [0, 0, -1, 1]
 
-    # 2차원 배열에서 현재 노드의 상하좌우를 검사하기 위한 dx와 dy
-    dx = [0, -1, 0, 1]
-    dy = [-1, 0, 1, 0]
 
-    # queue를 이용한 bfs 그래프 탐색
-    queue.append((x, y))
-    visited[x][y] = 1
+def bfs(graph, visited):
+    border = 0
+    queue = deque()
 
+    # 영역 개수 계산
+    for i in range(1, N + 1):
+        for j in range(1, N + 1):
+            # 현재 칸을 아직 방문하지 않았다면 현재 칸부터 bfs 탐색 시작
+            if visited[i][j] == 0:
+                # 영역 개수 한 개 증가
+                border += 1
+                queue.append((i, j))
 
-    while queue:
-        (x, y) = queue.popleft()
+                while queue:
+                    (x, y) = queue.popleft()
+                    # 방문처리
+                    visited[x][y] = 1
 
-        # queue에서 pop한 현재 노드를 기준으로 상하좌우 탐색
-        for k in range(4):
-            row = x + dx[k]
-            col = y + dy[k]
+                    # 상하좌우 인접한 칸으로 이동
+                    for k in range(4):
+                        nx = x + dx[k]
+                        ny = y + dy[k]
 
-            # 탐색 조건
-            # 1. 현재 노드가 배열의 인덱스 범위 안인지 0 <= x < n and 0 <= y < n
-            # 2. 같은 색인지
-            # 3. 방문하지 않았는지
-            if 0 <= row < n and 0 <= col < n:
-                if arr[x][y] == arr[row][col] and visited[row][col] == 0:
-                    queue.append((row, col))
-                    visited[row][col] = 1
+                        # 칸이 보드 밖으로 넘어가지 않았는지,인접한 칸이 같은 색인지,아직 방문하지 않았는지 확인
+                        if (1 <= nx <= N and 1 <= ny <= N) and graph[x][y] == graph[nx][ny] and visited[nx][ny] == 0:
+                            # 해당 칸 방문처리
+                            queue.append((nx, ny))
+                            visited[nx][ny] = 1
 
+    return border
 
-# 초기값 세팅
-n = int(input())
-visited = [[0] * n for _ in range(n)]
-arr = [list(input()) for _ in range(n)]
-queue = deque()
 
-# 적록색약이 아닌 경우의 답
-answerForNormal = 0
+# 입력받기
+N = int(input())
+graph = [[0] * (N + 1)]
+visited = [[0] * (N + 1) for _ in range(N + 1)]
 
-# 적록색약인 경우의 답
-answerForColorBlindness = 0
+for _ in range(N):
+    graph.append([0] + list(input()))
 
+# 정상인이 보는 영역 개수 반환
+num_of_normal = bfs(graph, visited)
 
-# 적록색약이 아닌 경우
-for i in range(n):
-    for j in range(n):
-        if visited[i][j] == 0:
-            bfs(i, j)
-            answerForNormal += 1
+# 적록색약이 보는 영역 개수 반환 적록색약은 R,G를 구분하지 못하므로 모든 R을 G로 변환
+for i in range(1, N + 1):
+    for j in range(1, N + 1):
+        if graph[i][j] == 'R':
+            graph[i][j] = 'G'
 
+visited = [[0] * (N + 1) for _ in range(N + 1)]
+num_of_abnormal = bfs(graph, visited)
 
-# 적록색약인 경우 R과 G는 같으므로
-
-for i in range(n):
-    for j in range(n):
-        if arr[i][j] == 'G':
-            arr[i][j] = 'R'
-
-visited = [[0] * n for _ in range(n)]
-for i in range(n):
-    for j in range(n):
-        if not visited[i][j]:
-            bfs(i,j)
-            answerForColorBlindness += 1
-
-print(answerForNormal, answerForColorBlindness)
+print(f"{num_of_normal} {num_of_abnormal}")

YoonYn9915/Graph/2024-07-01-[백준]-#10026-적록색약.py

@@ -0,0 +1,90 @@
+'''
+
+
+농부 해강이는 N X N칸으로 이루어진 나무판에서 버섯 농사를 짓는다. 나무판은 버섯이 자랄 수 있는 칸과 없는 칸으로 이루어져 있다.
+
+
+각 버섯 포자는 포자가 심어진 칸을 포함해 최대 K개의 연결된 (버섯이 자랄 수 있는) 칸에 버섯을 자라게 한다.
+이때 연결된 칸은 상하좌우로 적어도 한 변을 공유하는 칸들의 집합이라고 정의한다.
+
+또한 한 칸에 버섯 포자를 여러 개 겹쳐서 심을 수 있으며, 만약 x개의 버섯 포자를 겹쳐 심으면 포자가 심어진 칸을 포함해 최대
+x X K개의 연결된 (버섯이 자랄 수 있는) 칸에 버섯이 자란다.
+
+
+해강이는 버섯 포자를 심을 때 최소 개수로만 심으려고 한다.
+해강이가 농사가 가능할지 판단하고, 농사가 가능하다면 남은 버섯 포자의 개수를 출력하시오.
+버섯 포자를 하나라도 사용하고 버섯이 자랄 수 있는 모든 칸에 버섯이 전부 자랐을 때 농사가 가능하다고 정의한다.
+
+1. N X N 칸에서 버섯을 심어야 함. 이때 심은 버섯은 상하좌우 최대 K칸으로 확산.
+(버섯을 심은 칸을 시작으로 BFS 탐색 진행하면 해당 칸으로부터 버섯을 심을 수 있는 인접한 칸이 몇개인지 알수 있음)
+
+2. 2차원 배열을 순회하며 칸이 0이고 아직 방문하지 않았다면 거기서부터 BFS 탐색 시작.
+3. BFS 탐색으로 해당 칸으로부터 상하좌우 인접한 0(버섯 농사 가능 칸)이 몇 개인지 파악후 K개로 나누면 해당 구역에 몇개의 버섯 포자가 필요한지 계산 가능
+4. 2-3을 반복하며 모든 버섯 농사 가능 구역을 세며 총 몇개의 버섯 포자가 필요한지 계산
+5. 필요한 버섯 포자 개수가 M보다 크면 남은 버섯 개수를 출력 그렇지 않다면 IMPOSSIBLE 출력.
+5-1. 이떄 버섯 포자를 하나도 사용하지 않아도 IMPOSSIBLE 출력
+
+'''
+
+from collections import deque
+
+
+def bfs(i, j, visited):
+    dx = [-1, 1, 0, 0]
+    dy = [0, 0, -1, 1]
+
+    queue = deque()
+
+    # 시작점 방문처리
+    queue.append((i, j))
+    visited[i][j] = 1
+
+    # 시작점(x,y)으로부터 인접한 버섯 농사 가능 칸의 개수 (시작점 포함)
+    num = 1
+
+    while queue:
+        x, y = queue.popleft()
+
+        # 상하좌우 인접한 칸에 버섯 농사 가능한지 보기
+        for k in range(4):
+            nx = x + dx[k]
+            ny = y + dy[k]
+
+            # 그래프 범위에 있는지, 버섯 농사가 가능한지, 아직 방문하지 않았는지 확인
+            if (0 <= nx <= N - 1 and 0 <= ny <= N - 1) and graph[nx][ny] == 0 and visited[nx][ny] == 0:
+                # 방문처리
+                queue.append((nx, ny))
+                visited[nx][ny] = 1
+                # 버섯 농사 가능한 칸의 개수 증가
+                num += 1
+
+    # 해당 구역에 필요한 버섯 포자 개수 반환
+    if num % K == 0:
+        return num // K
+    else:
+        return (num // K) + 1
+
+
+# 입력받기
+N, M, K = map(int, input().split())
+
+# 나무판 배열
+graph = []
+# 나무판 방문 배열
+visited = [[0] * N for _ in range(N)]
+
+mushroom_count = 0
+
+for _ in range(N):
+    graph.append(list(map(int, input().split())))
+
+for i in range(N):
+    for j in range(N):
+        # 나무판이 버섯을 심을 수 있고, 아직 방문하지 않았으면
+        if graph[i][j] == 0 and visited[i][j] == 0:
+            mushroom_count += bfs(i, j, visited)
+
+if mushroom_count == 0 or mushroom_count > M:
+    print("IMPOSSIBLE")
+else:
+    print(f"POSSIBLE\n{M - mushroom_count}")

YoonYn9915/Graph/2025-04-01-[백준]-#27737-버섯 농장.py

@@ -0,0 +1,63 @@
+
+# 두 단어가 한글자만 다른지 확인하는 함수
+def count_same_letter(word1, word2):
+
+    count = 0
+    word_length = len(word1)
+    # 모든 단어의 길이는 같으므로 단어의 길이만큼 반복문 돌면서 같은 글자 계산
+    for i in range(word_length):
+        if word1[i] == word2[i]:
+            count += 1
+
+    if word_length - 1 == count:
+        return True
+    else:
+        return False
+
+
+
+def dfs(begin, target, words, depth):
+    global words_num
+    global min_value
+
+    # depth가 words의 크기보다 커지면 해당 탐색 종료
+    if depth > words_num:
+        return
+
+    # begin과 target이 같다면 탐색 종료
+    if begin == target:
+        # 현재 depth와 최솟값 비교
+        min_value = min(min_value, depth)
+        return
+
+    copy_words = words[:]
+
+    for i in range(len(words)):
+        # 두 단어가 한글자만 다르다면 그 단어로 변환
+        if count_same_letter(begin, words[i]):
+            # 단어 목록에서 현재 단어 제외하고
+            removed_word = copy_words.pop(i)
+            # 다음 detph dfs 실행
+            dfs(removed_word, target, copy_words, depth + 1)
+            # 배열 원복
+            copy_words.insert(i, removed_word)
+
+
+
+
+def solution(begin, target, words):
+
+    # target이 words에 없어서 변환할 수 없는 경우
+    if target not in words:
+        return 0
+
+    # 단어의 개수
+    global words_num
+    words_num = len(words)
+
+    global min_value
+    min_value = 10000
+
+    dfs(begin, target, words, 0)
+
+    return min_value

YoonYn9915/Graph/2025-04-06-[프로그래머스]-#43163-단어 변환.py

@@ -2,5 +2,7 @@
 
 | 사용자 | 챌린지 유형 | 문제 수 | 달성 여부 |
 | ------ | ----------- | ------- | --------- |
-| Mingguriguri | 그래프 | 2 | ❌ |
-| Mingguriguri | DP | 6 | ✅ |
+| Mingguriguri | 그래프 | 0 | ❌ |
+| Mingguriguri | DP | 5 | ✅ |
+| zaqquum | 그래프 | 0 | ❌ |
+| zaqquum | DP | 2 | ❌ |

_MonthlyChallenges/DASHBOARD.md

@@ -18,6 +18,17 @@
         "그래프": false,
         "DP": true
       }
+    },
+    "zaqquum": {
+      "그래프": [],
+      "DP": [
+        2169,
+        1520
+      ],
+      "achieved": {
+        "그래프": false,
+        "DP": false
+      }
     }
   }
 }