[20주차] 이혜원

BOJ/1000-5000번/HW_1967_2.java

@@ -0,0 +1,64 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+
+import java.util.List;
+import java.util.StringTokenizer;
+
+class HW_1967_2{
+    static List<Node>[] graph;
+    static boolean[] visited;
+    static int ans=0; // 트리의 지름
+    static int farNode=1; // 가장 먼 노드
+    static class Node{
+        int e, weight;
+        Node (int e, int weight){
+            this.e = e;
+            this.weight = weight;
+        }
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        int n = Integer.parseInt(br.readLine()); // 노드의 개수
+
+        graph = new ArrayList[n+1];
+        visited = new boolean[n + 1];
+
+        for(int i=1; i<=n; i++){
+            graph[i] = new ArrayList<>();
+        }
+        for(int i=0; i<n-1; i++){
+            st = new StringTokenizer(br.readLine());
+            int s = Integer.parseInt(st.nextToken());
+            int e = Integer.parseInt(st.nextToken());
+            int weight = Integer.parseInt(st.nextToken());
+
+            graph[s].add(new Node(e, weight)); // 양방향
+            graph[e].add(new Node(s, weight));
+        }
+        dfs(1, 0); // 루트 노드에서 가장 먼 노드 찾기
+
+        visited = new boolean[n + 1];
+        visited[farNode] = true;
+        dfs(farNode, 0);
+
+        System.out.println(ans);
+    }
+    private static void dfs(int node, int dist){
+        visited[node] = true;
+
+        if(ans < dist){
+            ans = dist;
+            farNode = node;
+        }
+
+        // for(요소타입 변수명 : 배열 or 컬렉션)
+        for(Node n : graph[node]){
+            if(!visited[n.e]){
+                dfs(n.e, dist + n.weight);
+            }
+        }
+    }
+}

BOJ/1000-5000번/HW_2110_2.java

@@ -0,0 +1,41 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.*;
+
+// 가장 인접한 두 공유기 사이의 최대 거리
+class HW_2110_2{
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken()); // 집의 개수
+        int C = Integer.parseInt(st.nextToken()); // 공유기의 개수
+
+        int[] arr = new int[N];
+        for(int i=0; i<N; i++) {
+            arr[i] = Integer.parseInt(br.readLine());
+        }
+        Arrays.sort(arr);
+        int s=1;
+        int e = arr[N - 1] - arr[0];
+        int ans = 0;
+
+        while(s<=e){ // Upper Bound
+            int start = arr[0];
+            int cnt = 1; // 첫번째 집은 설치
+            int mid = (s+e)/2; // 공유기 사이의 최소 거리
+            for(int i=1; i<N; i++){
+                if(mid <= arr[i]-start){
+                    cnt++;
+                    start = arr[i];
+                }
+            }
+            if(C <= cnt){
+                ans = mid;
+                s = mid+1;
+            } else e = mid-1;
+        }
+        System.out.println(ans);
+    }
+}

BOJ/1000-5000번/HW_2805_2.java

@@ -0,0 +1,43 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// 시간 복잡도 : N <= 10^6, M <=2*10^9, O(N logN)
+
+class HW_2805_2{
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        int N = Integer.parseInt(st.nextToken());
+        int M = Integer.parseInt(st.nextToken());
+        int[] arr = new int[N];
+        int s=0, e = 0;
+
+        st = new StringTokenizer(br.readLine());
+        for(int i=0;i <N; i++){
+            arr[i] = Integer.parseInt(st.nextToken());
+            e = Math.max(e, arr[i]);
+        }
+
+        Arrays.sort(arr);
+        while(s<=e){
+            int mid = (s+e)/2;
+            long sum = 0;
+            for(int h : arr){
+                if(0 < h-mid) {
+                    sum += h - mid;
+                }
+            }
+            if(sum < M){
+                e = mid-1;
+            }
+            else{
+                s = mid + 1;
+            }
+        }
+        System.out.println(e);
+    }
+}

BOJ/5001-10000번/HW_5021_2.java

@@ -0,0 +1,85 @@
+import java.io.*;
+import java.util.*;
+
+class HW_5021_2 {
+    static Map<String, List<String>> graph = new HashMap<>(); // 부모 정보를 저장하는 그래프
+    static Map<String, Double> blood = new HashMap<>(); // 혈통 비율 저장
+    static String king; // 왕조 창시자
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        int N = Integer.parseInt(st.nextToken()); // 가족 관계 개수
+        int M = Integer.parseInt(st.nextToken()); // 후보 수
+        king = br.readLine(); // 왕조 창시자 이름
+
+        blood.put(king, 1.0); // 창시자의 혈통 확률은 1.0
+
+        // 그래프 및 혈통 초기화
+        for (int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            String child = st.nextToken();
+            String parent1 = st.nextToken();
+            String parent2 = st.nextToken();
+
+            // 부모 연결 정보 저장 (자식 -> 부모 리스트)
+            graph.putIfAbsent(parent1, new ArrayList<>());
+            graph.putIfAbsent(parent2, new ArrayList<>());
+            graph.putIfAbsent(child, new ArrayList<>());
+            graph.get(child).add(parent1);
+            graph.get(child).add(parent2);
+
+            // 혈통 정보 초기화 (없다면 0.0)
+            blood.putIfAbsent(parent1, 0.0);
+            blood.putIfAbsent(parent2, 0.0);
+            blood.putIfAbsent(child, 0.0);
+        }
+
+        // BFS를 통해 혈통 확률 계산
+        bfs();
+
+        // 왕위 계승자 찾기
+        String successor = "";
+        double maxBlood = -1.0;
+
+        for (int i = 0; i < M; i++) {
+            String candidate = br.readLine();
+            if (blood.containsKey(candidate) && blood.get(candidate) > maxBlood) {
+                maxBlood = blood.get(candidate);
+                successor = candidate;
+            }
+        }
+
+        System.out.println(successor);
+    }
+
+    // BFS를 이용한 혈통 확률 계산
+    private static void bfs() {
+        Queue<String> queue = new LinkedList<>();
+
+        // 창시자(왕조 시작 인물)부터 시작
+        queue.add(king);
+
+        while (!queue.isEmpty()) {
+            String person = queue.poll();
+
+            if (!graph.containsKey(person)) continue; // 부모가 없는 경우 스킵
+
+            for (String child : graph.keySet()) {
+                List<String> parents = graph.get(child);
+                if (parents.size() < 2) continue; // 부모가 없으면 무시
+
+                double parent1Blood = blood.getOrDefault(parents.get(0), 0.0);
+                double parent2Blood = blood.getOrDefault(parents.get(1), 0.0);
+
+                double newBlood = (parent1Blood + parent2Blood) / 2.0;
+
+                if (newBlood > blood.get(child)) { // 새로운 혈통이 더 크면 갱신
+                    blood.put(child, newBlood);
+                    queue.add(child); // 혈통이 갱신된 경우 자식을 큐에 추가
+                }
+            }
+        }
+    }
+}

BOJ/5001-10000번/HW_7579_2.java

@@ -0,0 +1,45 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+// 시간복잡도 : N! (<=100) 시간 초과 -> dp로 중복 계산 줄이기
+// 필요한 메모리 M 바이트를 확보하기 위한 앱 비활성화의 최소의 비용을 계산
+// 메모리 활성화 or 비활성화
+class HW_7579_2{
+    static int[] coins;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken()); // 활성화 되어 있는 앱의 개수
+        int M = Integer.parseInt(st.nextToken()); // M 바이트 이상 메모리 추가 확보
+        int[] apps = new int[N];
+        st = new StringTokenizer(br.readLine());
+        for(int i=0; i<N; i++){ // 사용중인 바이트 수
+            apps[i] = Integer.parseInt(st.nextToken());
+        }
+
+        st = new StringTokenizer(br.readLine());
+        int[] costs = new int[N];
+        int sum =0;
+        for(int i=0; i<N; i++){ // 비활성화 했을 경우 비용
+            costs[i] = Integer.parseInt(st.nextToken());
+            sum += costs[i];
+        }
+
+        int[] dp = new int[sum+1];
+        for(int i=0; i<N; i++){
+            for(int j=sum; costs[i]<=j; j--){
+                dp[j] = Math.max(dp[j], dp[j-costs[i]] + apps[i]);
+            }
+        }
+
+        for(int i=0; i<=sum; i++){
+            if(M<=dp[i]){
+                System.out.println(i);
+                break;
+            }
+        }
+
+    }
+}

BOJ/5001-10000번/HW_9084_2.java

@@ -0,0 +1,33 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+// 시간복잡도 : N! (<=20) 시간 초과 -> dp로 중복 계산 줄이기
+
+class HW_9084_2{
+    static int[] coins;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        int T = Integer.parseInt(br.readLine());
+
+        while(T-->0){
+            int N = Integer.parseInt(br.readLine());
+            coins = new int[N];
+            st = new StringTokenizer(br.readLine());
+            for(int i=0; i<N; i++){
+                coins[i] = Integer.parseInt(st.nextToken());
+            }
+            int M = Integer.parseInt(br.readLine());
+            int[] dp = new int[M + 1];
+            dp[0] = 1; // 0원
+            for(int i=0; i<N; i++ ){
+                for(int j=coins[i]; j<M+1; j++){
+                    dp[j] += dp[j - coins[i]]; // 금액 j만들 때 동전(coin)추가
+                }
+            }
+            System.out.println(dp[M]);
+        }
+    }
+}

BOJ/5001-10000번/HW_9205_2.java

@@ -0,0 +1,54 @@
+import java.awt.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+class HW_9205_2{
+    static class Node{
+        int x, y;
+        public Node(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+
+        int t = Integer.parseInt(br.readLine());
+
+        while(t-->0){
+            int n = Integer.parseInt(br.readLine()); // 편의점 개수
+            Node[] nodes = new Node[n + 2];
+            for(int i=0; i<n+2; i++) {
+                st = new StringTokenizer(br.readLine());
+                int x = Integer.parseInt(st.nextToken());
+                int y = Integer.parseInt(st.nextToken());
+                nodes[i]  = new Node(x, y);
+            }
+            System.out.println(Bfs(nodes, n) ? "happy" : "sad");
+        }
+    }
+    private static boolean Bfs(Node[] nodes, int n) {
+        Queue<Node> queue = new LinkedList<>();
+        boolean[] visited = new boolean[n + 2];
+        queue.add(nodes[0]); // 시작(집)
+        visited[0] =true;
+        while(!queue.isEmpty()){
+            Node cur = queue.poll();
+            if(cal(cur, nodes[n+1]) <=1000){ // 현재 지점과 거리 계산
+                return true;
+            }
+            for(int i=1; i<n+2; i++){ // 편의점(1~n), 페스티벌(n+1) 모두 방문할 수 있는지 탐색
+                if(!visited[i] && cal(cur, nodes[i]) <= 1000){ // 이동 가능한 지
+                    visited[i] = true;
+                    queue.add(nodes[i]);
+                }
+            }
+        }
+        return false;
+    }
+    private static int cal(Node a, Node b){
+        return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    }
+}