solve: 코딩테스트 문제 풀이 - 20일차

Author: OhChangEun

2025-09-01/오창은/[solved] 백준_RGB 거리.java

@@ -0,0 +1,40 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+
+        int[][] costs = new int[n][3];
+        for (int i=0; i<n; i++) {
+            String[] parts = br.readLine().split(" ");
+            int rCost = Integer.parseInt(parts[0]);
+            int gCost = Integer.parseInt(parts[1]);
+            int bCost = Integer.parseInt(parts[2]);
+
+            costs[i][0] = rCost;
+            costs[i][1] = gCost;
+            costs[i][2] = bCost;
+        }
+
+        int[][] dp = new int[n][3];
+        dp[0][0] = costs[0][0];
+        dp[0][1] = costs[0][1];
+        dp[0][2] = costs[0][2];
+
+        for (int i=1; i<n; i++) {
+            dp[i][0] = costs[i][0] + Math.min(dp[i-1][1], dp[i-1][2]);
+            dp[i][1] = costs[i][1] + Math.min(dp[i-1][0], dp[i-1][2]);
+            dp[i][2] = costs[i][2] + Math.min(dp[i-1][0], dp[i-1][1]);
+        }
+
+        int minCost = Math.min(dp[n-1][0], Math.min(dp[n-1][1], dp[n-1][2]));
+        System.out.println(minCost);
+    }
+}

2025-09-01/오창은/[solved] 백준_트리의 지름.java

@@ -0,0 +1,75 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+    static int N;
+
+    static class Node {
+        int to, weight;
+        public Node (int to, int weight) {
+            this.to = to;
+            this.weight = weight;
+        }
+    }
+
+    static List<Node>[] tree;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        N = Integer.parseInt(br.readLine());
+
+        tree = new ArrayList[N+1]; // 1~N
+        for (int i=1; i<=N; i++) {
+            tree[i] = new ArrayList<>();
+        }
+
+        for (int i=0; i<N; i++) {
+            String[] parts = br.readLine().split(" ");
+            int from = Integer.parseInt(parts[0]);
+            for (int j=1; j<parts.length; j+=2) {
+                int num = Integer.parseInt(parts[j]);
+                if (num == -1) break;
+                int weight = Integer.parseInt(parts[j+1]);
+
+                tree[from].add(new Node(num, weight));
+            }
+        }
+
+        // System.out.print(tree[4].get(2).weight + " ");
+        int[] result1 = bfs(1);
+        int farNode = result1[0];
+
+        int[] result2 = bfs(farNode);
+        int maxDistance = result2[1];
+        System.out.println(maxDistance);
+    }
+
+    public static int[] bfs(int start) {
+        boolean[] visited = new boolean[N+1];
+        int[] distance = new int[N+1];
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(start);
+        visited[start] = true;
+
+        int target = start;
+        int maxDistance = 0;
+        while (!queue.isEmpty()) {
+            int curr = queue.poll();
+
+            for (Node next: tree[curr]) {
+                if (!visited[next.to]) {
+                    visited[next.to] = true;
+                    queue.offer(next.to);
+                    distance[next.to] = distance[curr] + next.weight;
+                }
+
+                if (distance[next.to] > maxDistance) {
+                    maxDistance = distance[next.to];
+                    target = next.to;
+                }
+            }
+        }
+        return new int[] {target, maxDistance};
+    }
+}

2025-09-01/오창은/[solved] 프로그래머스_아이템 줍기.java

@@ -0,0 +1,72 @@
+import java.util.;
+
+class Solution {
+    int[][] map = new int[102][102];
+    boolean[][] visited = new boolean[102][102];
+    int[] dx = {0, 0, -1, 1};
+    int[] dy = {1, -1, 0, 0};
+    
+    public int solution(int[][] rectangle, int characterX, int characterY, int itemX, int itemY) {
+        for (int[] r rectangle) {
+            int x1 = r[0]  2;
+            int y1 = r[1]  2;
+            int x2 = r[2]  2;
+            int y2 = r[3]  2;
+            
+            for (int x=x1; x=x2; x++) {
+                map[y1][x] = 1;
+                map[y2][x] = 1;
+            }
+            
+            for (int y=y1; y=y2; y++) {
+                map[y][x1] = 1;
+                map[y][x2] = 1;
+            }
+        }
+        
+        for (int[] r rectangle) {
+            int x1 = r[0]  2;
+            int y1 = r[1]  2;
+            int x2 = r[2]  2;
+            int y2 = r[3]  2;
+           
+            for (int x = x1+1; x  x2; x++) {
+                for (int y = y1+1; y  y2; y++) {
+            		map[y][x] = 0;        
+                }    
+            }
+        }
+        
+        int result = bfs(characterX  2, characterY  2, itemX  2, itemY  2);
+        result = 2;
+        
+        return result;
+    }
+    
+    public int bfs(int startX, int startY, int targetX, int targetY) {
+        Queueint[] queue = new LinkedList();
+        queue.offer(new int[] {startX, startY, 0});
+        visited[startY][startX] = true; 
+        
+        while (!queue.isEmpty()) {
+            int[] curr = queue.poll();
+            int cx = curr[0], cy = curr[1], distance = curr[2];
+            
+            if (cx == targetX && cy == targetY) {
+                return distance; 
+            }
+            for (int i=0; i4; i++) {
+                int nx = cx + dx[i];
+                int ny = cy + dy[i];
+                
+                if (nx = 0 && nx  102 && ny = 0 && ny  102) {
+                    if (!visited[ny][nx] && map[ny][nx] == 1) {
+                        visited[ny][nx] = true;
+                        queue.offer(new int[] {nx, ny, distance + 1});
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+}