week 34

Author: jinu12

thursday/week33/jinu/BOJ1072.java

@@ -4,6 +4,11 @@
 
 public class BOJ1072 {
 
+    // Y /X ∗100=Z이고, 판수를 더 올려 승률이 Z에서 변화하게 될 때의 승률은 무조건 감소하지 않고 증가합니다.
+    // 그래서 판 수(X) 와 이긴 횟수(Y)를 mid 만큼 늘려 승률을 계산합니다.
+    // 결과적으로 승률에 변동이 생기면, 해당 횟수 answer 에 담고, 더 적은 횟수로 승률 변동이 있는지 확인하기 위해 상한값을 조정하고
+    // 변동이 없다면, 더 많은 게임 횟수 범위 내를 확인하기 위해 하한값을 조정
+
     static int X, Y, Z;
 
     public static void main(String[] args) {

thursday/week34/jinu/BOJ1475.java

@@ -0,0 +1,27 @@
+package thursday.week34.jinu;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ1475 {
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String N = br.readLine();
+        int[] numSet = new int[10];
+        for (char c : N.toCharArray()) {
+            int num = c - '0';
+            if (num == 9) {
+                num = 6;
+            }
+            numSet[num]++;
+        }
+
+        // 6과 9는 바꿀 수 있으므로 2로 나눔
+        numSet[6] = numSet[6] / 2 + numSet[6] % 2;
+
+        Arrays.sort(numSet);
+        // 오름차순 정렬이므로 마지막 요소 출력
+        System.out.println(numSet[9]);
+    }
+}

thursday/week34/jinu/BOJ1757.java

@@ -0,0 +1,34 @@
+package thursday.week34.jinu;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ1757 {
+
+    public static void main(String[] args) throws NumberFormatException, IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(bf.readLine());
+        int N = Integer.parseInt(st.nextToken());
+        int M = Integer.parseInt(st.nextToken());
+        int[] arr = new int[N + 1];
+        for (int i = 1; i <= N; i++) {
+            arr[i] = Integer.parseInt(bf.readLine());
+        }
+        int[] psum = new int[N + 1];
+        for (int i = 1; i <= N; i++) {
+            psum[i] = psum[i - 1] + arr[i];
+        }
+        int[] dp = new int[N + 2];
+        for (int i = 1; i <= N + 1; i++) {
+            dp[i] = Math.max(dp[i], dp[i - 1]);
+            for (int j = 1; j <= M && i + 2 * j <= N + 1; j++) {
+                dp[i + 2 * j] = Math.max(dp[i + 2 * j], dp[i] + psum[i + j - 1] - psum[i - 1]);
+            }
+        }
+
+        System.out.println(dp[N + 1]);
+
+    }
+
+}

thursday/week34/jinu/BOJ2477.java

@@ -0,0 +1,69 @@
+package thursday.week34.jinu;
+
+import java.util.*;
+import java.io.*;
+
+public class BOJ2477 {
+
+    public static void main(String[] args) throws IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+
+        int N = Integer.parseInt(br.readLine());
+        int[] arr = new int[6];
+        int MaxWidthI = 0, MaxWidth = 0, MaxHeight = 0, MaxHeightI = 0, d;
+        for (int i = 0; i < 6; i++) {
+            st = new StringTokenizer(br.readLine());
+            d = Integer.parseInt(st.nextToken());
+            arr[i] = Integer.parseInt(st.nextToken());
+
+            // 가장 긴 가로의 길이와 위치 찾기
+            if ((d == 1 || d == 2) && MaxWidth < arr[i]) {
+                MaxWidth = arr[i];
+                MaxWidthI = i;
+            }
+
+            // 가장 긴 세로의 길이와 위치 찾기
+            else if ((d == 3 || d == 4) && MaxHeight < arr[i]) {
+                MaxHeight = arr[i];
+                MaxHeightI = i;
+            }
+        }
+
+        int right, left, minWidth, minHeight;
+
+        if (MaxWidthI + 1 == 6) {
+            right = 0;
+        } else {
+            right = MaxWidthI + 1;
+        }
+
+        if (MaxWidthI - 1 == -1) {
+            left = 5;
+        } else {
+            left = MaxWidthI - 1;
+        }
+
+        minHeight = Math.abs(arr[right] - arr[left]);
+
+        if (MaxHeightI + 1 == 6) {
+            right = 0;
+        } else {
+            right = MaxHeight + 1;
+        }
+
+        if (MaxHeightI - 1 == -1) {
+            left = 5;
+        } else {
+            left = MaxHeightI - 1;
+        }
+
+        // 빈 사각형의 가로 길이
+        minWidth = Math.abs(arr[right] - arr[left]);
+
+        System.out.println(((MaxWidth + MaxHeight) - (minHeight + minWidth)) * N);
+
+    }
+
+}

thursday/week34/jinu/BOJ6118.java

@@ -0,0 +1,81 @@
+package thursday.week34.jinu;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ6118 {
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb = new StringBuilder();
+
+        int num, line;
+        int one, two;
+        int[] maxIdx = new int[3];
+        Queue<Point> queue = new LinkedList<>();
+        boolean[] visited;
+        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        num = Integer.parseInt(st.nextToken());
+        line = Integer.parseInt(st.nextToken());
+
+        visited = new boolean[num + 1];
+
+        for (int x = 0; x <= num; x++) {
+            list.add(new ArrayList<>());
+        }
+
+        for (int x = 0; x < line; x++) {
+            st = new StringTokenizer(br.readLine());
+
+            one = Integer.parseInt(st.nextToken());
+            two = Integer.parseInt(st.nextToken());
+
+            list.get(one).add(two);
+            list.get(two).add(one);
+        }
+
+        queue.add(new Point(1, 0));
+        visited[1] = true;
+
+        while (!queue.isEmpty()) {
+            Point now = queue.poll();
+
+            // 최대 거리 계산
+            if (now.move > maxIdx[1]) {
+                maxIdx[0] = now.edge;
+                maxIdx[1] = now.move;
+                maxIdx[2] = 1;
+            } else if (now.move == maxIdx[1]) {
+                maxIdx[2]++;
+                maxIdx[0] = Math.min(maxIdx[0], now.edge);
+            }
+
+            // 다음 노드 탐색
+            for (int x : list.get(now.edge)) {
+                if (visited[x])
+                    continue;
+
+                visited[x] = true;
+                queue.add(new Point(x, now.move + 1));
+            }
+        }
+
+        for (int x : maxIdx)
+            sb.append(x).append(" ");
+
+        System.out.println(sb);
+
+    }
+
+    public static class Point {
+        int edge, move;
+
+        Point(int edge, int move) {
+            this.edge = edge;
+            this.move = move;
+        }
+    }
+
+}

thursday/week34/jinu/BOJ6497.java

@@ -0,0 +1,80 @@
+package thursday.week34.jinu;
+
+import java.util.*;
+import java.io.*;
+
+public class BOJ6497 {
+
+    static int[] parent;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        while (true) {
+
+            String[] inputs = br.readLine().split(" ");
+
+            int m = Integer.parseInt(inputs[0]);
+            int n = Integer.parseInt(inputs[1]);
+            if (m == 0 && n == 0) {
+                return;
+            }
+
+            int[][] edges = new int[n][3];
+
+            int total_cost = 0;
+            for (int i = 0; i < n; i++) {
+                inputs = br.readLine().split(" ");
+
+                int x = Integer.parseInt(inputs[0]);
+                int y = Integer.parseInt(inputs[1]);
+                int z = Integer.parseInt(inputs[2]);
+
+                edges[i][0] = x;
+                edges[i][1] = y;
+                edges[i][2] = z;
+
+                total_cost += edges[i][2];
+
+            }
+
+            Arrays.sort(edges, (a, b) -> a[2] - b[2]);
+
+            parent = new int[m + 1];
+            for (int i = 1; i <= m; i++) {
+                parent[i] = i;
+            }
+
+            int min_cost = 0;
+            int selected_cnt = 0;
+            int i = 0;
+            while (true) {
+                if (find(edges[i][0]) != find(edges[i][1])) {
+                    union(edges[i][0], edges[i][1]);
+                    min_cost += edges[i][2];
+                    selected_cnt++;
+                }
+                if (selected_cnt == m - 1) {
+                    break;
+                }
+                i++;
+            }
+            System.out.println(total_cost - min_cost);
+        }
+
+    }
+
+    public static int find(int idx) {
+        if (parent[idx] == idx) {
+            return idx;
+        }
+        parent[idx] = find(parent[idx]);
+        return parent[idx];
+    }
+
+    public static void union(int a, int b) {
+        int parent_of_a = find(a);
+        parent[parent_of_a] = b;
+    }
+
+}