week44: leesuyong

PROGRAMMERS/[42861] 섬 연결하기/Solution.java

@@ -0,0 +1,44 @@
+package PRO_42861_섬연결하기;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+
+class Solution {
+
+    int[] parent;
+
+    int findParent(int x) {
+        if (parent[x] == x) return x;
+        return parent[x] = findParent(parent[x]);
+    }
+
+    void union(int x, int y) {
+        int px = findParent(x);
+        int py = findParent(y);
+        if (px != py) parent[px] = py;
+    }
+
+    public int solution(int n, int[][] costs) {
+        parent = new int[n];
+        for (int i = 0; i < n; i++) {
+            parent[i] = i;
+        }
+
+        Arrays.sort(costs, (a, b) -> a[2] - b[2]);
+
+        int answer = 0;
+        for (int[] cost : costs) {
+            int x = cost[0];
+            int y = cost[1];
+            int w = cost[2];
+
+            if (findParent(x) != findParent(y)) {
+                union(x, y);
+                answer += w;
+            }
+        }
+
+        return answer;
+    }
+}

PROGRAMMERS/[42897] 스티커 모으기/leesuyong849/Main.java

@@ -0,0 +1,39 @@
+class Solution {
+    public int solution(int[] sticker) {
+        int n = sticker.length;
+
+
+        //예외처리
+        if (n == 1) {
+            return sticker[0];
+        }
+        if (n == 2) {
+            return Math.max(sticker[0], sticker[1]);
+        }
+
+        int case1 = linearDP(sticker, 1, n - 1);
+
+        int case2 = linearDP(sticker, 0, n - 2);
+
+        return Math.max(case1, case2);
+    }
+
+    // start ~ end 구간에서 인접한 원소를 동시에 선택할 수 없을 때 최대 합
+    private int linearDP(int[] sticker, int start, int end) {
+        int len = end - start + 1;
+
+        if (len == 1) {
+            return sticker[start];
+        }
+
+        int[] dp = new int[len];
+        dp[0] = sticker[start];
+        dp[1] = Math.max(sticker[start], sticker[start + 1]);
+
+        for (int i = 2; i < len; i++) {
+            dp[i] = Math.max(dp[i - 1], dp[i - 2] + sticker[start + i]);
+        }
+
+        return dp[len - 1];
+    }
+}

PROGRAMMERS/[43164] 여행경로/leesuyong849/Main.java

@@ -0,0 +1,43 @@
+package BOJ_43164_여행경로;
+
+import java.util.*;
+
+class Solution {
+    public String[] solution(String[][] tickets) {
+        String[] answer = {};
+        HashMap<String, List<String>> graph = new HashMap<>();
+
+        for (String[] ticket : tickets) {
+            String from = ticket[0];
+            String to = ticket[1];
+            graph.computeIfAbsent(from, k -> new ArrayList<>()).add(to);
+        }
+
+        //알파벳 순서로 가기로 했으므로 하나의 출발지에서 갈 수 있는 목적지들을 정렬
+        for (List<String> value : graph.values()) {
+            Collections.sort(value);
+        }
+
+        ArrayDeque<String> stack = new ArrayDeque<>();
+        LinkedList<String> route = new LinkedList<>();
+
+        //여행의 시작은 인천
+        stack.push("ICN");
+
+        while(!stack.isEmpty()) {
+            String cur = stack.peek();
+            List<String> des = graph.get(cur);
+
+            if (des != null && !des.isEmpty()) {
+                String next = des.remove(0);
+                stack.push(next);
+            } else {
+                //이 도시에서 더 이상 갈 곳이 없다면 문제에서 주어진 모든 티켓을 사용한다는 조건이 있으므로
+                //이 도시는 여기서 확정된다.
+                route.addFirst(stack.pop());
+            }
+        }
+
+        return route.toArray(new String[0]);
+    }
+}

PROGRAMMERS/[49189] 가장 먼 노드/leesuyong849/Main.java

@@ -0,0 +1,59 @@
+package BOJ_49189_가장먼노드;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Main {
+
+}
+
+class Solution {
+    public int solution(int n, int[][] edge) {
+
+        ArrayList<Integer>[] map = new ArrayList[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            map[i] = new ArrayList<>();
+        }
+        for (int i = 0; i < edge.length; i++) {
+            int a = edge[i][0];
+            int b = edge[i][1];
+            map[a].add(b);
+            map[b].add(a);
+        }
+
+        boolean[] visited = new boolean[n + 1];
+        int[] dist = new int[n + 1];
+
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(1);
+        visited[1] = true;
+        //얼마나 떨어져 있는지 저장
+        dist[1] = 0;
+
+        while (!queue.isEmpty()) {
+            int cur = queue.poll();
+            for (int next : map[cur]) {
+                if (!visited[next]) {
+                    visited[next] = true;
+                    dist[next] = dist[cur] + 1;
+                    queue.add(next);
+                }
+            }
+        }
+
+        //저장된 데이터 찾아서 얼마나 떨어졌는지 확ㅇ니
+        int maxDist = 0;
+        for (int i = 1; i <= n; i++) {
+            maxDist = Math.max(maxDist, dist[i]);
+        }
+
+        int answer = 0;
+        for (int i = 1; i <= n; i++) {
+            if (dist[i] == maxDist) {
+                answer++;
+            }
+        }
+        return answer;
+    }
+}