[최원준] Day02

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

@@ -0,0 +1,59 @@
+package Leetcode;
+
+/*
+1. 아이디어 :
+
+
+2. 시간복잡도 :
+O( )
+
+3. 자료구조/알고리즘 :
+
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Q993 {
+/*
+
+ * 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 {
+    List<Integer> depths = new ArrayList<>();
+    List<Integer> parents = new ArrayList<>();
+    int x, y;
+
+    public void dfs(TreeNode node, int par, int depth) {
+        if (node == null) return;
+        if (node.val == x || node.val == y) {
+            depths.add(depth);
+            parents.add(par);
+        }
+
+        dfs(node.left, node.val, depth+1);
+        dfs(node.right, node.val, depth+1);
+    }
+
+    public boolean isCousins(TreeNode root, int x, int y) {
+        this.x = x;
+        this.y = y;
+        dfs(root, -1, 0);
+
+        return (depths.get(0) == depths.get(1) && parents.get(0) != parents.get(1));
+    }
+}
+ */
+}

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

@@ -0,0 +1,73 @@
+package Leetcode;
+
+/*
+1. 아이디어 :
+
+
+2. 시간복잡도 :
+O( )
+
+3. 자료구조/알고리즘 :
+
+ */
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Q3366 {
+    class Solution {
+        List<Integer> nums = new ArrayList<>();
+        int k, n;
+        Integer[][][] dp;
+
+        public int dfs(int idx, int op1, int op2) {
+            if (idx == n) return 0;
+            if (dp[idx][op1][op2] != null) return dp[idx][op1][op2];
+
+            int num = nums.get(idx);
+            int ans = num + dfs(idx+1, op1, op2);
+
+            if (op1 > 0) {
+                int val = (num+1)/2;
+                ans = Math.min(ans, val + dfs(idx+1, op1-1, op2));
+            }
+
+            if (op2 > 0 && num >= k) {
+                int val = num - k;
+                ans = Math.min(ans, val + dfs(idx+1, op1, op2-1));
+            }
+
+            if (op1 > 0 && op2 > 0) {
+                int val1 = (num+1)/2;
+                if (val1 >= k) {
+                    int val2 = val1 -k;
+                    ans = Math.min(ans, val2 + dfs(idx+1, op1-1, op2-1));
+                }
+            }
+
+            if (op1 > 0 && op2 > 0) {
+                if (num >= k) {
+                    int val1 = num -k;
+                    int val2 = (val1+1)/2;
+                    ans = Math.min(ans, val2 + dfs(idx+1, op1-1, op2-1));
+                }
+            }
+
+            dp[idx][op1][op2] = ans;
+            return ans;
+        }
+
+        public int minArraySum(int[] ns, int k, int op1, int op2) {
+            for (int num : ns) nums.add(num);
+            Collections.sort(nums, Collections.reverseOrder());
+            System.out.println(nums);
+            this.k = k;
+            this.n = nums.size();
+            dp = new Integer[n+1][op1+1][op2+1];
+
+            return dfs(0, op1, op2);
+
+        }
+    }
+}