240125

src/MST/BOJ_13905_세부.java

@@ -0,0 +1,99 @@
+package MST;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+/**
+ * [문제 분석]
+ * 각 다리마다 다리 위를 지날 수 있는 무게 제한이 존재한다
+ * 자신이 머물던 집에서 혜빈이에게 갈 수 있는 최대한의 금빼빼로만을 들고 가려고 한다
+ *
+ * 이때, 숭이의 출발 위치에서 혜빈이의 위치까지 숭이가 들고 갈 수 있는 금빼빼로의 최대 개수를 구하라
+ *
+ * [문제 풀이]
+ *
+ */
+public class BOJ_13905_세부 {
+
+    static int V, E, s, e;
+    static Edge[] edges;
+    static int[] parents;
+    static class Edge implements Comparable<Edge> {
+        int from, to, weight;
+
+        public Edge(int from, int to, int weight) {
+            this.from = from;
+            this.to = to;
+            this.weight = weight;
+        }
+
+        @Override
+        public int compareTo(Edge o) {
+            return (weight - o.weight) * -1;  // 내림차순 정렬
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        V = Integer.parseInt(st.nextToken());
+        E = Integer.parseInt(st.nextToken());
+
+        st = new StringTokenizer(br.readLine());
+        s = Integer.parseInt(st.nextToken());
+        e = Integer.parseInt(st.nextToken());
+
+        edges = new Edge[E];
+        parents = new int[V+1];
+        for (int i = 1; i <= V; i++) {
+            parents[i] = i;
+        }
+        for (int i = 0; i < E; i++) {
+            st = new StringTokenizer(br.readLine());
+            int from = Integer.parseInt(st.nextToken());
+            int to = Integer.parseInt(st.nextToken());
+            int weight = Integer.parseInt(st.nextToken());
+
+            edges[i] = new Edge(from, to, weight);
+        }
+
+        System.out.println(solution());
+    }
+
+    private static int solution() {
+        Arrays.sort(edges);  // 가중치 기준 내림차순 정렬
+
+        int res = 0;
+        for (Edge edge : edges) {
+            if (find(edge.from) != find(edge.to)) {
+                union(edge.from, edge.to);
+                if (find(s) == find(e)) {
+                    res = edge.weight;  // 내림차순 정렬이므로 반복문이 진행될수록 값이 작아짐. 그 값이 곧 문제의 답
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+
+    private static void union(int x, int y) {
+        int rootX = find(x);
+        int rootY = find(y);
+
+        if (rootY > rootX) {
+            parents[rootY] = rootX;
+        } else {
+            parents[rootX] = rootY;
+        }
+    }
+
+    private static int find(int x) {
+        if (parents[x] == x) return x;
+        return parents[x] = find(parents[x]);
+    }
+}

src/graph/BOJ_16948_데스나이트.java

@@ -0,0 +1,64 @@
+package graph;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ_16948_데스나이트 {
+
+    static int N, r1, c1, r2, c2;
+    static int[] di = {-2, -2, 0, 0, 2, 2};
+    static int[] dj = {-1, 1, -2, 2, -1, 1};
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        N = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        r1 = Integer.parseInt(st.nextToken());
+        c1 = Integer.parseInt(st.nextToken());
+        r2 = Integer.parseInt(st.nextToken());
+        c2 = Integer.parseInt(st.nextToken());
+
+        System.out.println(solution());
+    }
+
+    private static int solution() {
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[N][N];
+
+        queue.add(new int[]{r1, c1});
+        visited[r1][c1] = true;
+
+        int depth = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+
+            while (size-- > 0) {
+                int[] cur = queue.poll();
+                int i = cur[0], j = cur[1];
+
+                if (i == r2 && j == c2) return depth;
+
+                for (int d = 0; d < di.length; d++) {
+                    int ni = i + di[d];
+                    int nj = j + dj[d];
+
+                    if (ni < 0 || nj < 0 || ni >= N || nj >= N) continue;
+                    if (visited[ni][nj]) continue;
+
+                    queue.add(new int[]{ni, nj});
+                    visited[ni][nj] = true;
+                }
+            }
+
+            depth++;
+        }
+
+        return -1;
+    }
+
+}

src/greedy/BOJ_1398_동전문제.java

@@ -0,0 +1,58 @@
+package greedy;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+
+/**
+ * [문제 분석]
+ * K >= 0을 만족하는 모든 K에 대해
+ * 가치가 10^K, 25*100^K 인 동전이 있다
+ * 각 동전의 개수는 무한하고, 초콜릿을 구매할 때는 정확하게 그 가격만큼만 지불해야 한다
+ *
+ * 초콜릿 가격이 주어질 때, 구매에 필요한 동전의 최솟값을 구하라
+ *
+ * [문제 풀이]
+ * 사용할 수 있는 동전의 액수를 오름차순으로 나열하였을 때, {1, 10, 25} * 100^n 의 규칙으로 반복된다
+ * 따라서, 주어진 수 N을 100 단위로 나누어가며 동전의 개수를 구한다
+ */
+public class BOJ_1398_동전문제 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb = new StringBuilder();
+
+        int T = Integer.parseInt(br.readLine());
+        while (T-- > 0) {
+            long N = Long.parseLong(br.readLine());
+            sb.append(solution(N)).append('\n');
+        }
+
+        System.out.println(sb);
+    }
+
+    private static int solution(long N) {
+        int cnt = 0;
+
+        int[] dp = new int[100];
+        int[] coins = {1, 10, 25};
+
+        for (int i = 1; i < 100; i++) {
+            dp[i] = i;
+            for (int coin : coins) {
+                if (i >= coin) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+
+        while (N > 0) {
+            cnt += dp[(int) (N % 100)];
+            N /= 100;
+        }
+
+        return cnt;
+    }
+
+}