Merge pull request #211 from AlgorithmStudy-Allumbus/minjeong3

Minjeong / 5월 3주차 / 4문제

Author: Mingguriguri

minjeong/DFSBFS/2025-05-19-[백준]-#7576-토마토.py

@@ -0,0 +1,49 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+# 1. 입력 처리
+M, N = map(int, input().split())                            # 가로 칸 수, 세로 칸 수
+box = [list(map(int, input().split())) for _ in range(N)]   # 토마토
+
+# 2. 초기 설정
+queue = deque([])                               # 큐
+directions = [(-1, 0), (0, 1), (1, 0), (0, -1)] # 방향벡터
+day = 0                                         # 정답이 담길 변수
+
+# 3. 큐에 초기 익은 토마토 위치 저장
+for i in range(N):
+    for j in range(M):
+        if box[i][j] == 1:
+            queue.append((i, j))
+
+# 4. BFS 탐색
+while queue:
+    # 처음 토마토 꺼내기
+    x, y = queue.popleft()
+
+    # 처음 토마토의 인접한 토마토 찾기
+    for dx, dy in directions:
+        nx, ny = x + dx, y + dy
+
+        # 범위 내에 있고, 토마토가 익지 않은 경우
+        if (0 <= nx < N and 0 <= ny < M) and (box[nx][ny] == 0):
+            # 익히고 1 더해주며 횟수 세기
+            # 여기서 나온 제일 큰 값이 정답이 된다.
+            box[nx][ny] += box[x][y] + 1  # 일수 누적
+            queue.append((nx, ny))
+
+
+# 5. 정답 구하기
+for row in box:
+    for tomato in row:
+        # 모두 탐색했지만 토마토가 모두 익지 않았다면 -1 출력
+        if tomato == 0:
+            print(-1)
+            exit()
+
+    # 다 익혔다면 최댓값이 정답
+    day = max(day, max(row))
+
+# 6. 정답 출력
+print(day - 1) # 처음에 1로 익은 토마토를 표현했으니 1을 빼준다.

minjeong/DFSBFS/2025-05-20-[백준]-#7569-토마토(3차원).py

@@ -0,0 +1,45 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+# 1. 입력 처리
+M, N, H = map(int, input().split()) # 가로, 세로, 높이
+box = [[list(map(int, input().split())) for _ in range(N)] for _ in range(H)]
+
+# 2. 초기 변수 설정
+queue = deque([])
+directions = [(-1, 0, 0), (0, 1, 0), (1, 0, 0), (0, -1, 0),
+              (0, 0, 1), (0, 0, -1)]    # 위-오른쪽-아래-왼쪽-앞-뒤
+day = 0                                 # 정답으로 반환할 변수
+
+# 3. 초기 익은 토마토를 큐에 추가하기
+for i in range(H):
+    for j in range(N):
+        for k in range(M):
+            if box[i][j][k] == 1:
+                queue.append((i, j, k))
+
+# 4. BFS 탐색
+while queue:
+    z, y, x = queue.popleft()
+
+    for dx, dy, dz in directions:
+        nx, ny, nz = x + dx, y + dy, z + dz
+        # 범위 내에 있고 아직 안 익은 토마토라면
+        if (0 <= nx < M and 0 <= ny < N and 0 <= nz < H) and (box[nz][ny][nx] == 0):
+            box[nz][ny][nx] += box[z][y][x] + 1  # 익은 날짜 누적 갱신
+            queue.append((nz, ny, nx))
+
+# 5. 정답 구하기
+for height in box:
+    for row in height:
+        for tomato in row:
+            # 안 익은 토마토가 남아있는지 여부 확인
+            if tomato == 0:
+                print(-1)
+                exit()
+        # 익는데 걸린 최대 일수 추적
+        day = max(day, max(row))
+
+# 6. 정답 출력
+print(day - 1)

minjeong/Stack, Queue, Priority Queue/2025-05-18-[PGS]-다리를지나는트럭(java).java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+class Solution {
+    public int solution(int bridge_length, int weight, int[] truck_weights) {
+
+        Queue<Integer> bridge = new LinkedList<>();
+        for (int i = 0; i < bridge_length; i++) {
+            bridge.offer(0);    // 처음에 빈 칸으로 채워둔다.
+        }
+
+        int time = 0;    // 전체 경과 시간
+        int current = 0;       // 다리 위 현재 무게 합
+        int idx = 0;        // 다음에 보낼 트럭 인덱스
+
+        while (idx < truck_weights.length || current > 0) {
+            time++;
+            // 1. 다리에서 한 칸 빠져나옴
+            int left = bridge.poll();
+            current -= left; // 빠져나간 게 0일수도 있고, 트럭일 수도 있음.
+
+            // 2. 다음 트럭을 올릴 수 있으면 올리기, 아니면 빈 칸(0) 올리기
+            if (idx < truck_weights.length && current + truck_weights[idx] <= weight) {
+                bridge.offer(truck_weights[idx]);
+                current += truck_weights[idx];
+                idx++;
+            }
+            else {
+                bridge.offer(0);
+            }
+        }
+        return time;
+    }
+}

minjeong/Stack, Queue, Priority Queue/2025-05-19-[PGS]-주식가격(java).java

@@ -0,0 +1,52 @@
+/* 내 풀이 */
+import java.util.*;
+
+
+class Solution {
+    public int[] solution(int[] prices) {
+        int[] answer = new int[prices.length];
+
+        for (int i = 0; i < answer.length; i++) {
+            for (int j = i+1; j < answer.length; j++) {
+                answer[i] += 1;
+                if (prices[i] > prices[j] ) {
+                    break;
+                }
+            }
+        }
+        return answer;
+    }
+}
+
+/* 스택 풀이 */
+import java.util.Stack;
+
+public class Solution {
+    public int[] solution(int[] prices) {
+        int n = prices.length;
+        int[] answer = new int[n];
+        // 아직 가격이 떨어지지 않은 시점들의 인덱스를 담을 스택
+        Stack<Integer> st = new Stack<>();
+
+        for (int i = 0; i < n; i++) {
+            // 지금 가격(prices[i])이 스택 위 시점의 가격보다 낮다면,
+            // 그 시점의 가격은 i 시점에 떨어진 것이므로
+            // answer[idx] = i - idx 로 구간 길이를 확정짓고 pop
+            while (!st.isEmpty() && prices[st.peek()] > prices[i]) {
+                int idx = st.pop();
+                answer[idx] = i - idx;
+            }
+            // 현재 시점 i를 스택에 추가
+            st.push(i);
+        }
+
+        // 마지막까지 가격이 떨어지지 않은 인덱스들은
+        // 끝까지(마지막 인덱스 n-1) 버틴 시간이 (n-1) - idx
+        while (!st.isEmpty()) {
+            int idx = st.pop();
+            answer[idx] = (n - 1) - idx;
+        }
+
+        return answer;
+    }
+}