[최원준]Day16

leetcode2/1easy/최원준/Q617.java

@@ -0,0 +1,43 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+재귀로 풀 수 있습니다.
+
+2. 시간복잡도 :
+O( n )
+
+3. 자료구조/알고리즘 :
+- / -
+ */
+
+public class Q617 {
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+
+class Solution {
+    public TreeNode mergeTrees(TreeNode node1, TreeNode node2) {
+        if (node1 != null && node2 != null) {
+            node1.val += node2.val;
+            node1.left = mergeTrees(node1.left, node2.left);
+            node1.right = mergeTrees(node1.right, node2.right);
+            return node1;
+        } else {
+            return node1 != null? node1 : node2;
+        }
+    }
+}
+ */
+}

leetcode2/2medium/최원준/Q1296.java

@@ -0,0 +1,48 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+n이 k로 나눠지지 않으면 false를 리턴
+
+정렬 후, 가장 작은 숫자부터 k개씩 묶어서 카운터 해시맵을 갱신.
+
+2. 시간복잡도 :
+O( nlogn )
+
+3. 자료구조/알고리즘 :
+- / -
+ */
+
+import java.util.*;
+
+public class Q1296 {
+    class Solution {
+        public boolean isPossibleDivide(int[] nums, int k) {
+            int n = nums.length;
+            if (n%k != 0) return false;
+
+            Map<Integer, Integer> counter = new HashMap<>();
+            List<Integer> distinctNums = new ArrayList<>();
+            for (int num : nums) {
+                if (!counter.containsKey(num)) {
+                    counter.put(num, 1);
+                    distinctNums.add(num);
+                } else {
+                    counter.put(num, counter.get(num)+1);
+                }
+            }
+            Collections.sort(distinctNums);
+
+            for (int num : distinctNums) {
+                int count = counter.get(num);
+                if (count==0) continue;
+                for (int i = num; i<num+k; i++) {
+                    counter.put(i, counter.getOrDefault(i, 0)-count);
+                    if (counter.get(i) < 0) return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

leetcode2/3hard/최원준/Q2463.java

@@ -0,0 +1,78 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+dp문제.
+로봇, 공장을 정렬한 후, 공장들을 펼칩니다.
+dp[i][j] = i번째 로봇이 j번째 공장으로 갔을때의 최소값.
+
+dfs를 사용.
+종료조건:
+- 로봇을 모두 순회했으면 0을 리턴
+- 공장을 모두 순회했으면 Long.MAX_VALUE를 리턴 (로봇이 남았음)
+
+현재 로봇을 j번째 공장으로 보내고, 다음 로봇을 j+1번째 공장으로 보내는 경우와
+현재 로봇을 j+1번째 공장으로 보내는 경우를 비교
+- 이때 가능한 경우인지 확인
+- j+2번째 공장으로 보내는 경우는, helper를 호출함으로 내부적으로 처리됨.
+
+2. 시간복잡도 :
+O( n * m ) m = 공장이 수용할 수 있는 로봇의 수.
+
+3. 자료구조/알고리즘 :
+dp / dfs
+ */
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class Q2463 {
+    class Solution {
+        Long[][] dp;
+        List<Integer> robot;
+        int[][] factory;
+        int[] totalFactory;
+        int n;
+        int m=0;
+
+        public long minimumTotalDistance(List<Integer> robot, int[][] factory) {
+            Collections.sort(robot);
+            Arrays.sort(factory, (a, b)->a[0]-b[0]);
+            this.robot = robot;
+            this.factory = factory;
+            n = robot.size();
+
+
+            for (int[] f : factory) m += f[1];
+            totalFactory = new int[m];
+            int idx = 0;
+            for (int[] f : factory) for (int i=0; i<f[1]; i++) {
+                totalFactory[idx++] = f[0];
+            }
+            System.out.println(Arrays.toString(totalFactory));
+            if (m<n) return -1;
+
+            dp = new Long[n][m];
+            //i번째 로봇이 j번째 공장으로 갔을때의 최소값
+            //j번째 공장에 갔으면, 그 다음은 j+1번쨰 공장부터 avail까지.
+            return helper(0, 0);
+        }
+
+        public long helper(int i, int j) {
+            if (i == n) return 0;
+            if (j == m) return Long.MAX_VALUE; // robots left
+            if (dp[i][j] != null) return dp[i][j];
+
+            dp[i][j] = helper(i, j+1); // 현재 로봇을 j+1 공장으로
+
+            long next = helper(i+1, j+1); // 현재 로봇을 j 공장으로 가고, 다음 로봇을 j+1 공장으로
+            if (next != Long.MAX_VALUE) {
+                long a = Math.abs(robot.get(i) - totalFactory[j]) + next;
+                dp[i][j] = Math.min(dp[i][j], a);
+            }
+            return dp[i][j];
+
+        }
+    }
+}