update

hard/4.median-of-two-sorted-arrays.java

@@ -0,0 +1,28 @@
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        if (nums2.length < nums1.length) return findMedianSortedArrays(nums2, nums1);
+        int m = nums1.length, n = nums2.length;
+        int k = (m + n + 1) / 2;
+        int beg1 = 0, end1 = m;
+        while (beg1 <= end1) {
+            int i = beg1 + (end1 - beg1) / 2;
+            int j = k - i;
+            if (0 < i && nums2[j] < nums1[i - 1]) {
+                end1 = i - 1; // Take too much
+            } else if (i < m && nums1[i] < nums2[j - 1]) {
+                beg1 = i + 1; // Take too little
+            } else {
+                int maxOfLeft = 0, minOfRight = 0;
+                if (i == 0) maxOfLeft = nums2[j - 1];
+                else if (j == 0) maxOfLeft = nums1[i - 1];
+                else maxOfLeft = Math.max(nums1[i-1], nums2[j-1]);
+                if (((m + n) & 1) == 1) return (double) maxOfLeft;
+                if (i == m) minOfRight = nums2[j];
+                else if (j == n) minOfRight = nums1[i];
+                else minOfRight = Math.min(nums1[i], nums2[j]);
+                return (maxOfLeft + minOfRight) / 2.0;
+            }
+        }
+        return -1.0;
+    }
+}

hard/679.java

@@ -0,0 +1,37 @@
+import java.util.ArrayList;
+
+class Solution {
+    private static final double eps = 0.000001;
+
+    public boolean judgePoint24(int[] nums) {
+        ArrayList<Double> list = new ArrayList<>();
+        for (int n : nums) list.add((double) n);
+        return dfs(list);
+    }
+
+    private boolean dfs(ArrayList<Double> list) {
+        if (list.size() == 1 && Math.abs(list.get(0) - 24.0) < eps) return true;
+        for (int i = 0; i < list.size() - 1; i++) {
+            for (int j = i + 1; j < list.size(); j++) {
+                ArrayList<Double> candidate = new ArrayList<>();
+                double n1 = list.get(i), n2 = list.get(j);
+                candidate.add(n1 + n2);
+                candidate.add(n1 - n2);
+                candidate.add(n2 - n1);
+                candidate.add(n1 * n2);
+                if (n2 != 0.0) candidate.add(n1 / n2);
+                if (n1 != 0.0) candidate.add(n2 / n1);
+                ArrayList<Double> next = new ArrayList<>();
+                for (int k = 0; k < list.size(); k++)
+                    if (k != i && k != j)
+                        next.add(list.get(k));
+                for (int k = 0; k < candidate.size(); k++) {
+                    next.add(candidate.get(k));
+                    if (dfs(next)) return true;
+                    next.remove(next.size() - 1);
+                }
+            }
+        }
+        return false;
+    }
+}