feat: 3주차 - PG_43105 정수 삼각형 문제 풀이[윤주찬]

src/week02/Juchan/PG_42586.java

@@ -0,0 +1,77 @@
+package week02.Juchan;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class PG_42586 {
+    static class Solution {
+        public int[] solution(int[] progresses, int[] speeds) {
+            // 각 작업이 완료되기까지 남은 '일 수'를 저장할 큐
+            Queue<Integer> queue = new LinkedList<>();
+
+            //(100-진도율)/개발 속도를 통해 남은 일 수 계산
+            for (int i = 0; i < progresses.length; i++) {
+                int day = (int) Math.ceil((100.0 - progresses[i]) / speeds[i]); //ex 3.8888 일이면 4일 필요하기에 ceil 함수를 사용해서 올림 처리 후 형 변환
+                queue.offer(day);
+            }
+            List<Integer> result = new ArrayList<>();
+
+            // 첫번 째 배포 일 수를 뽑아냅니다.
+            while (!queue.isEmpty()) {
+                int current = queue.poll();
+                int count = 1;
+
+                // 배포일과 비교하여 큐의 첫 번째 일 수가 작거나 같으면 같이 묶어서 리스트에 저장합니다.
+                while (!queue.isEmpty() && queue.peek() <= current) {
+                    queue.poll();
+                    count++;
+                }
+                result.add(count);
+            }
+            int[] answer = new int[result.size()];
+            for (int i = 0; i < result.size(); i++) {
+                answer[i] = result.get(i);
+            }
+            return answer;
+        }
+    }
+
+    public static void main(String[] args) { //테스트
+        Solution solution = new Solution();
+
+
+        int[] progresses = {93, 30, 55};
+        int[] speeds = {1, 30, 5};
+
+        int[] result = solution.solution(progresses, speeds);
+
+
+        System.out.print("[");
+        for (int i = 0; i < result.length; i++) {
+            System.out.print(result[i]);
+            if (i != result.length - 1) { //마지막 요소는 , 를 빼줍니다.
+                System.out.print(", ");
+            }
+        }
+        System.out.println("]");
+        // 예상 출력: [2, 1]
+    }
+}
+
+
+/**
+ * 문제
+ * 각각 기능은 진도(progress) 가 있고, 매일 각 기능마다 개발 속도(speed) 만큼 진도가 올라간다.
+ * 기능은 진도가 100% 이상이 되어야 배포 할 수 있다.
+ * 배포는 하루에 한 번, 하루가 끝난 후 진행한다.
+ * 진도가 뒤에 있는 기능이 앞 기능보다 빨리 끝날 수 있는데 뒤에 있는 기능은 앞 기능이 배포되는 시점에 같이 배포된다.
+ * <p>
+ * 풀이 방법
+ * 1. 각 기능마다 100%가 될 때까지 걸리는 날을 계산한다.(100-진도율)/개발 속도
+ * 2. 큐에서 가장 앞에 있는 기능을 꺼내 배포일을 지정한다.
+ * 3. 배포일보다 작업이 먼저 끝난 뒤에 있는 기능도 같이 묶어준다.
+ * 4. 묶인 기능의 수를 리스트에 넣어준다.
+ * 5. 리스트를 출력한다.
+ */

src/week03/Juchan/PG_43105.java

@@ -0,0 +1,57 @@
+package week03.Juchan;
+
+class Solution {
+    public int solution(int[][] triangle) {
+        int n = triangle.length;
+        int[][] dp = new int[n][n]; // 합을 넣어둘 배열 생성
+
+        dp[0][0] = triangle[0][0]; // 초기값은 꼭대기의 값
+
+        for (int i = 1; i < n; i++) {
+            //맨 왼쪽
+            dp[i][0] = dp[i - 1][0] + triangle[i][0];
+            for (int j = 1; j < i; j++) {
+                dp[i][j] = Math.max(dp[i - 1][j - 1], dp[i - 1][j]) + triangle[i][j]; // 중간에 있는 값은 전 인덱스의 왼쪽 값과 오른쪽 값중 큰 값으로 설정
+            }
+
+            // 맨 오른쪽
+            dp[i][i] = dp[i - 1][i - 1] + triangle[i][i];
+        }
+        int answer = 0;
+        for (int i = 0; i < n; i++) {
+            answer = Math.max(answer, dp[n - 1][i]); // 최댓값을 갱신
+        }
+        return answer;
+    }
+}
+
+public class PG_43105 {
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        int[][] triangle = {
+                {7},
+                {3, 8},
+                {8, 1, 0},
+                {2, 7, 4, 4},
+                {4, 5, 2, 6, 5}
+        };
+        int result = s.solution(triangle);
+        System.out.println(result); // 예상 출력: 30
+    }
+}
+
+
+/**
+ * 문제
+ * 숫자가 들어간 피라미드 형태의 삼각형이 주어진다.
+ * 꼭대기부터 바닥까지 인접한 숫자를 따라 내려가면서 만들 수 있는 최대 합을 구하라.
+ * <p>
+ * 풀이 요약
+ * - 각 위치까지의 최대 합을 저장할 dp 배열을 선언한다.
+ * - 첫 번째 행(dp[0][0])은 초기값으로 triangle[0][0]을 넣는다.
+ * - 그다음 행부터는 규칙적으로 채운다:
+ * 1. 맨 왼쪽 값(dp[i][0])은 바로 위 행의 같은 인덱스(dp[i-1][0])에서만 내려올 수 있다.
+ * 2. 맨 오른쪽 값(dp[i][i])은 바로 위 행의 오른쪽 대각선 왼쪽(dp[i-1][i-1])에서만 내려올 수 있다.
+ * 3. 그 외 중간 값(dp[i][j])은 바로 위(dp[i-1][j]) 또는 왼쪽 대각선(dp[i-1][j-1]) 중 큰 값에 현재 triangle[i][j]를 더한다.
+ * - 마지막 행(dp[n-1])에서 최댓값을 찾아서 반환한다.
+ */