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

Author: OhChangEun

2025-08-31/오창은/[solved] 백준_거짓말.java

@@ -0,0 +1,83 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+    static int N; // 사람 수
+    static int M; // 파티 수
+    static int truthCount; // 진실을 아는 사람 수
+    static int[] truthArr; // 진실을 아는 사람
+
+    static int[] parent;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String[] parts = br.readLine().split(" ");
+
+        N =  Integer.parseInt(parts[0]);
+        M =  Integer.parseInt(parts[1]);
+
+        parts = br.readLine().split(" ");
+        truthCount = Integer.parseInt(parts[0]);
+        truthArr = new int[truthCount];
+        for (int i=0; i<truthCount; i++) {
+            truthArr[i] = Integer.parseInt(parts[i+1]);
+        }
+
+        List<List<Integer>> parties = new ArrayList<>();
+        while (M-- > 0) {
+            parts = br.readLine().split(" ");
+            int n = Integer.parseInt(parts[0]);
+            List<Integer> party = new ArrayList<>();
+            for (int i=0; i<n; i++) {
+                party.add(Integer.parseInt(parts[i + 1]));
+            }
+            parties.add(party);
+        }
+        parent = new int[N + 1];
+        for (int i=1; i<=N; i++) {
+            parent[i] = i;
+        }
+
+        for (List<Integer> party: parties) {
+            for (int i=1; i<party.size(); i++) {
+                union(party.get(0), party.get(i));
+            }
+        }
+
+        Set<Integer> truthRoots = new HashSet<>();
+        for (int t: truthArr) {
+            truthRoots.add(find(t));
+        }
+
+        int answer = 0;
+        for (List<Integer> party: parties) {
+            boolean canLie = true;
+            for (int p: party) {
+                if (truthRoots.contains(find(p))) {
+                    canLie = false;
+                    break;
+                }
+            }
+            if (canLie)
+                answer++;
+        }
+        System.out.println(answer);
+    }
+
+    public static int find(int x) {
+        if (parent[x] == x) return x;
+        return parent[x] = find(parent[x]);
+    }
+    public static void union(int a, int b) {
+        int rootA = find(a);
+        int rootB = find(b);
+
+        if (rootA > rootB) {
+            parent[rootA] = rootB;
+        } else {
+            parent[rootB] = rootA;
+        }
+    }
+}

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

@@ -0,0 +1,81 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.*;
+
+public class Main {
+    static class Node {
+        int to, weight;
+        public Node(int to, int weight) {
+            this.to = to;
+            this.weight = weight;
+        }
+    }
+    static int n;
+    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];
+        for (int i=1; i<=n; i++) {
+            tree[i] = new ArrayList<>();
+        }
+        for (int i=0; i<n-1; i++) {
+            String[] parts = br.readLine().split(" ");
+            int u = Integer.parseInt(parts[0]);
+            int v = Integer.parseInt(parts[1]);
+            int weight = Integer.parseInt(parts[2]);
+
+            tree[u].add(new Node(v, weight));
+            tree[v].add(new Node(u, weight));
+        }
+
+        int[] result1 = bfs(1);
+        int farNode = result1[0];
+
+        int[] result2 = bfs(farNode);
+        int answer = result2[1];
+
+        System.out.println(answer);
+
+        /*
+        for (int i=1; i<=n; i++) {
+            for (Node next: tree[i]) {
+                System.out.print(next.to + " ");
+            }
+            System.out.println();
+        }
+         */
+    }
+    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 maxDistance = 0;
+        int farNode = start;
+        while (!queue.isEmpty()) {
+            int curr = queue.poll();
+
+            for (Node next: tree[curr]) {
+                if (!visited[next.to]) {
+                    visited[next.to] = true;
+                    distance[next.to] = distance[curr] + next.weight;
+                    queue.offer(next.to);
+
+                    if (distance[next.to] > maxDistance) {
+                        maxDistance = distance[next.to];
+                        farNode = next.to;
+                    }
+                }
+            }
+        }
+
+        return new int[] {farNode, maxDistance};
+    }
+}

2025-08-31/오창은/[solved] 프로그래머스_줄 서는 방법.java

@@ -0,0 +1,27 @@
+import java.util.*;
+
+class Solution {
+    public int[] solution(int n, long k) {
+        List<Integer> numbers = new ArrayList<>();
+        for (int i=1; i<=n; i++) {
+            numbers.add(i);
+        }
+        
+        int[] result = new int[n];
+        long[] fact = new long[n+1];
+        fact[0] = 1;
+        for (int i=1; i<=n; i++) {
+            fact[i] = fact[i-1] * i;
+        }
+        
+        k--; 
+        for (int i=0; i<n; i++) {
+			long f = fact[n - 1 - i];
+            int index = (int)(k / f);
+            result[i] = numbers.remove(index);
+            k %= f;
+        }
+        
+        return result;
+    }
+}