[한종욱-19주차 알고리즘 스터디]

한종욱:10주차/boj10216.java

@@ -0,0 +1,98 @@
+import java.io.*;
+import java.util.*;
+
+public class boj10216 {
+    // 입출력을 위한 BufferedReader, BufferedWriter 선언
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static final StringBuilder sb = new StringBuilder();
+
+    // 분리집합(서로소 집합)의 루트 노드들을 저장하는 집합
+    private static Set<Integer> set;
+
+    // 유니온-파인드를 위한 배열 (x, y, r, parent)
+    private static int[][] uf;
+
+    // 각 집합의 크기를 저장하는 배열
+    private static int[] size;
+
+    // 적군 진영의 수
+    private static int n;
+
+    public static void main(String[] args) throws IOException {
+        int t = Integer.parseInt(br.readLine());  // 테스트 케이스 개수
+
+        for (int i = 0; i < t; i++) {
+            init();            // 초기 데이터 설정 및 연결 관계 계산
+            getDisjointSets();  // 분리된 집합의 수 계산
+            sb.append(set.size()).append("\n");  // 결과 저장
+        }
+
+        bw.write(sb.toString());  // 모든 결과 출력
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    // 초기 데이터를 설정하고 연결 관계를 계산하는 메소드
+    private static void init() throws IOException {
+        n = Integer.parseInt(br.readLine());  // 적군 진영의 수
+
+        // 배열 초기화
+        uf = new int[n][4];  // [x좌표, y좌표, 통신 반경, 부모 인덱스]
+        size = new int[n];    // 각 집합의 크기
+        set = new HashSet<>();  // 분리집합의 루트 노드 집합
+
+        // 각 진영 정보 입력 및 연결 관계 계산
+        for (int i = 0; i < n; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            uf[i][0] = Integer.parseInt(st.nextToken());  // x좌표
+            uf[i][1] = Integer.parseInt(st.nextToken());  // y좌표
+            uf[i][2] = Integer.parseInt(st.nextToken());  // 통신 반경
+            uf[i][3] = i;  // 자기 자신을 부모로 초기화
+            size[i] = 1;   // 초기 집합 크기는 1
+
+            // 이전에 입력받은 모든 진영과의 연결 여부 확인
+            for (int j = 0; j < i; j++) {
+                // 두 진영의 통신 반경 합의 제곱이 두 점 사이의 거리의 제곱보다 크거나 같으면 연결 가능
+                // (r1 + r2)^2 >= (x1 - x2)^2 + (y1 - y2)^2
+                if ((uf[i][2] + uf[j][2]) * (uf[i][2] + uf[j][2])
+                    >= Math.abs(uf[i][0] - uf[j][0]) * Math.abs(uf[i][0] - uf[j][0])
+                    + Math.abs(uf[i][1] - uf[j][1]) * Math.abs(uf[i][1] - uf[j][1])) {
+                    union(i, j);  // 두 진영을 같은 집합으로 합침
+                }
+            }
+        }
+    }
+
+    // 두 집합을 합치는 메소드
+    private static void union(int x, int y) {
+        int X = find(x);  // x의 루트 찾기
+        int Y = find(y);  // y의 루트 찾기
+
+        if (X == Y) return;  // 이미 같은 집합이면 종료
+
+        // 더 작은 집합을 더 큰 집합에 합침 (최적화)
+        if (size[X] < size[Y]) {
+            uf[X][3] = Y;         // X의 부모를 Y로 설정
+            size[Y] += size[X];  // Y 집합의 크기 증가
+        } else {
+            uf[Y][3] = X;         // Y의 부모를 X로 설정
+            size[X] += size[Y];  // X 집합의 크기 증가
+        }
+    }
+
+    // 요소의 루트를 찾는 메소드 (경로 압축 사용)
+    private static int find(int x) {
+        if (uf[x][3] == x) return x;  // 자기 자신이 루트인 경우
+        return uf[x][3] = find(uf[x][3]);  // 경로 압축
+    }
+
+    // 분리된 집합의 수를 계산하는 메소드
+    private static void getDisjointSets() {
+        for (int i = 0; i < n; i++) {
+            int root = find(i);  // 각 요소의 루트 찾기
+            if (!set.contains(root)) set.add(root);  // 새로운 루트면 집합에 추가
+        }
+    }
+}

한종욱:10주차/boj1947.java

@@ -0,0 +1,41 @@
+import java.io.*;
+
+public class boj1947 {
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static final int MOD = 1000000000;  // 나머지 연산을 위한 모듈러 값
+    private static long[] dp;  // 완전 순열의 경우의 수를 저장할 배열
+    private static int n;      // 사람의 수
+
+    public static void main(String[] args) throws IOException {
+        init();  // 초기 설정 및 DP 계산
+        bw.write(String.valueOf(dp[n]));  // 결과 출력
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    // 완전 순열(어느 누구도 자신의 선물을 받지 않는 순열)의 경우의 수 계산
+    private static void init() throws IOException {
+        n = Integer.parseInt(br.readLine());  // 사람 수 입력
+        dp = new long[n + 1];  // DP 배열 초기화
+
+        // 기본 케이스 설정
+        dp[0] = 1;  // 0명일 때는 1가지 경우 (아무도 없는 경우)
+        dp[1] = 0;  // 1명일 때는 0가지 경우 (자신의 선물을 받지 않을 방법 없음)
+
+        // 점화식을 이용한 DP 계산
+        // 완전 순열의 점화식: D(n) = (n-1) * (D(n-1) + D(n-2))
+        for (int i = 2; i <= n; i++) {
+            /*
+             * 이 점화식의 의미:
+             * 1. i번째 사람이 j번째 사람에게 선물을 줄 때(j != i)
+             * 2. 두 가지 경우가 발생:
+             *    a. j번째 사람이 i번째 사람에게 선물을 줌 -> 나머지 n-2명에 대한 완전 순열 문제(dp[i-2])
+             *    b. j번째 사람이 i번째 사람에게 선물을 주지 않음 -> i와 j를 제외한 나머지에 대한 완전 순열(dp[i-1])
+             * 3. 이를 j의 n-1가지 경우에 대해 모두 계산
+             */
+            dp[i] = (i-1)*(dp[i-1] + dp[i-2]) % MOD;  // 오버플로우 방지를 위한 모듈러 연산
+        }
+    }
+}

한종욱:10주차/boj2591.java

@@ -0,0 +1,57 @@
+import java.io.*;
+
+public class boj2591 {
+    // 입출력을 위한 BufferedReader, BufferedWriter 선언
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+    // 동적 프로그래밍을 위한 배열
+    private static int[] dp;  // dp[i]: i길이까지의 숫자를 해석하는 경우의 수
+
+    // 입력된 숫자 카드의 길이
+    private static int n;
+
+    public static void main(String[] args) throws IOException {
+        init();  // 초기 데이터 설정 및 DP 계산
+
+        // 결과 출력
+        bw.write(String.valueOf(dp[n]));
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    /**
+     * 초기 데이터를 설정하고 DP를 계산하는 메소드
+     * 1~34까지의 숫자로 해석하는 경우의 수를 계산합니다.
+     */
+    private static void init() throws IOException {
+        String input = br.readLine();  // 숫자 카드 입력
+        n = input.length();  // 숫자 카드 길이
+        dp = new int[n + 1];  // DP 배열 초기화
+
+        // 기본 경우: 빈 문자열은 1가지 방법으로 해석 가능
+        dp[0] = 1;
+
+        // 각 위치까지의 해석 방법 수 계산
+        for (int i = 1; i <= n; i++) {
+            char current = input.charAt(i - 1);  // 현재 숫자
+
+            // 한 자리 숫자로 해석하는 경우 (0이 아닐 때만 가능)
+            if (current != '0') {
+                dp[i] += dp[i - 1];  // 이전 위치까지의 해석 방법 수를 더함
+            }
+
+            // 두 자리 숫자로 해석하는 경우 (두 번째 자리부터 가능)
+            if (i > 1) {
+                char prev = input.charAt(i - 2);  // 이전 숫자
+                int twoDigitNum = (prev - '0') * 10 + (current - '0');  // 두 자리 숫자 계산
+
+                // 두 자리 숫자가 10~34 범위이고 첫 자리가 0이 아닐 때
+                if (prev != '0' && twoDigitNum >= 10 && twoDigitNum <= 34) {
+                    dp[i] += dp[i - 2];  // 두 자리 전까지의 해석 방법 수를 더함
+                }
+            }
+        }
+    }
+}

한종욱:10주차/boj4386.java

@@ -0,0 +1,119 @@
+import java.io.*;
+import java.util.*;
+
+public class boj4386 {
+    // 입출력을 위한 BufferedReader, BufferedWriter 선언
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+    // stars[i][0]: i번째 별의 x좌표, stars[i][1]: i번째 별의 y좌표
+    private static double[][] stars;
+
+    // 각 별까지의 최소 거리를 저장하는 배열
+    private static double[] dist;
+
+    // 방문 여부를 체크하는 배열
+    private static boolean[] visited;
+
+    // 별의 개수
+    private static int n;
+
+    public static void main(String[] args) throws IOException {
+        init();  // 초기 데이터 설정
+
+        // 프림 알고리즘으로 최소 신장 트리 구성
+        double answer = prim(0);
+
+        // 소수점 둘째 자리까지 출력 (반올림)
+        bw.write(String.valueOf(Math.round(answer*100)/100.0));
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    /**
+     * 초기 데이터를 설정하는 메소드
+     * 별의 개수와 좌표를 입력받아 초기화합니다.
+     */
+    private static void init() throws IOException {
+        n = Integer.parseInt(br.readLine());  // 별의 개수 입력
+
+        // 배열 초기화
+        stars = new double[n][2];  // 별 좌표 배열
+        dist = new double[n];      // 최소 거리 배열
+        visited = new boolean[n];  // 방문 체크 배열
+
+        // 최소 거리를 매우 큰 값으로 초기화 (무한대 역할)
+        Arrays.fill(dist, 1e6);
+
+        // 각 별의 좌표 입력
+        for (int i = 0; i < n; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            double x = Double.parseDouble(st.nextToken());
+            double y = Double.parseDouble(st.nextToken());
+            stars[i][0] = x;
+            stars[i][1] = y;
+        }
+    }
+
+    /**
+     * 프림 알고리즘을 사용하여 최소 신장 트리를 구성하는 메소드
+     * @param start 시작 별의 인덱스
+     * @return 최소 신장 트리의 가중치 합 (최소 비용)
+     */
+    private static double prim(int start) {
+        // 우선순위 큐를 사용하여 거리가 가장 짧은 별부터 선택
+        // [별 인덱스, 거리]를 저장
+        PriorityQueue<double[]> pq = new PriorityQueue<>((o1, o2) -> Double.compare(o1[1], o2[1]));
+
+        double sum = 0.0;  // 최소 신장 트리의 총 가중치
+
+        dist[start] = 0.0;  // 시작 별까지의 거리는 0
+        pq.add(new double[]{start, dist[start]});  // 시작 별을 큐에 추가
+
+        // 모든 별을 연결할 때까지 반복
+        while (!pq.isEmpty()) {
+            double[] current = pq.poll();  // 거리가 가장 짧은 별 선택
+            int currentStar = (int)current[0];  // 현재 별의 인덱스
+
+            // 이미 방문한 별이면 스킵
+            if (visited[currentStar]) continue;
+
+            // 현재 별 방문 처리 및 가중치 합산
+            visited[currentStar] = true;
+            sum += current[1];  // 현재까지의 거리를 합산
+
+            // 다른 모든 별과의 거리 계산
+            for (int i = 0; i < n; i++) {
+                // 자기 자신이거나 이미 방문한 별은 스킵
+                if (i == currentStar || visited[i]) continue;
+
+                // 현재 별에서 i번째 별까지의 거리 계산
+                double newDist = distance(
+                    stars[currentStar][0], stars[currentStar][1],
+                    stars[i][0], stars[i][1]
+                );
+
+                // 기존 거리보다 더 짧으면 업데이트
+                if (newDist < dist[i]) {
+                    dist[i] = newDist;
+                    pq.add(new double[]{i, dist[i]});  // 업데이트된 별을 큐에 추가
+                }
+            }
+        }
+
+        return sum;  // 최소 신장 트리의 총 가중치 반환
+    }
+
+    /**
+     * 두 점 사이의 유클리드 거리를 계산하는 메소드
+     * @param x1 첫 번째 점의 x좌표
+     * @param y1 첫 번째 점의 y좌표
+     * @param x2 두 번째 점의 x좌표
+     * @param y2 두 번째 점의 y좌표
+     * @return 두 점 사이의 거리
+     */
+    private static double distance(double x1, double y1, double x2, double y2) {
+        return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+    }
+}