Improved tags

Author: javadev

src/main/java/g3401_3500/s3451_find_invalid_ip_addresses/script.sql

@@ -1,5 +1,5 @@
 # Write your MySQL query statement below
-# #Hard #2025_02_16_Time_383_ms_(85.47%)_Space_0.0_MB_(100.00%)
+# #Hard #Database #2025_02_18_Time_393_ms_(79.56%)_Space_0.0_MB_(100.00%)
 WITH cte_invalid_ip AS (
     SELECT log_id, ip
     FROM logs

src/main/java/g3401_3500/s3452_sum_of_good_numbers/Solution.java

@@ -1,16 +1,13 @@
 package g3401_3500.s3452_sum_of_good_numbers;
 
-// #Easy #2025_02_16_Time_1_ms_(100.00%)_Space_44.30_MB_(100.00%)
+// #Easy #Array #2025_02_18_Time_1_ms_(99.99%)_Space_44.75_MB_(7.31%)
 
 public class Solution {
     public int sumOfGoodNumbers(int[] nums, int k) {
         int totalSum = 0;
         int n = nums.length;
         for (int i = 0; i < n; i++) {
-            boolean isGood = true;
-            if (i - k >= 0 && nums[i] <= nums[i - k]) {
-                isGood = false;
-            }
+            boolean isGood = i - k < 0 || nums[i] > nums[i - k];
             if (i + k < n && nums[i] <= nums[i + k]) {
                 isGood = false;
             }

src/main/java/g3401_3500/s3453_separate_squares_i/Solution.java

@@ -1,42 +1,34 @@
 package g3401_3500.s3453_separate_squares_i;
 
-// #Medium #2025_02_16_Time_123_ms_(100.00%)_Space_87.97_MB_(_%)
+// #Medium #Array #Binary_Search #2025_02_18_Time_60_ms_(99.96%)_Space_88.58_MB_(26.92%)
 
 public class Solution {
-    private double helper(double line, int[][] squares) {
-        double aAbove = 0;
-        double aBelow = 0;
-        for (int[] square : squares) {
-            int y = square[1];
-            int l = square[2];
-            double total = (double) l * l;
-            if (line <= y) {
-                aAbove += total;
-            } else if (line >= y + l) {
-                aBelow += total;
+    public double separateSquares(int[][] squares) {
+        long hi = 0L;
+        long lo = 1_000_000_000L;
+        for (int[] q : squares) {
+            lo = Math.min(lo, q[1]);
+            hi = Math.max(hi, q[1] + q[2]);
+        }
+        while (lo <= hi) {
+            long mid = (lo + hi) / 2;
+            if (diff(mid, squares) <= 0) {
+                hi = mid - 1;
             } else {
-                // The line intersects the square.
-                double aboveHeight = (y + l) - line;
-                double belowHeight = line - y;
-                aAbove += l * aboveHeight;
-                aBelow += l * belowHeight;
+                lo = mid + 1;
             }
         }
-        return aAbove - aBelow;
+        double diff1 = diff(hi, squares);
+        double diff2 = diff(lo, squares);
+        return (double) hi + diff1 / (diff1 - diff2);
     }
 
-    public double separateSquares(int[][] squares) {
-        double lo = 0;
-        double hi = 2 * 1e9;
-        for (int i = 0; i < 60; i++) {
-            double mid = (lo + hi) / 2.0;
-            double diff = helper(mid, squares);
-            if (diff > 0) {
-                lo = mid;
-            } else {
-                hi = mid;
-            }
+    private double diff(long mid, int[][] squares) {
+        double[] res = new double[2];
+        for (int[] q : squares) {
+            res[0] += Math.min(q[2], Math.max(0, mid - q[1])) * q[2];
+            res[1] += Math.min(q[2], Math.max(0, q[1] + q[2] - mid)) * q[2];
         }
-        return hi;
+        return res[1] - res[0];
     }
 }

src/main/java/g3401_3500/s3454_separate_squares_ii/Solution.java

@@ -1,176 +1,154 @@
 package g3401_3500.s3454_separate_squares_ii;
 
-// #Hard #2025_02_16_Time_246_ms_(100.00%)_Space_79.98_MB_(100.00%)
+// #Hard #Array #Binary_Search #Segment_Tree #Line_Sweep
+// #2025_02_18_Time_156_ms_(80.18%)_Space_79.96_MB_(64.32%)
 
+import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Comparator;
+import java.util.List;
 
 public class Solution {
-    public double separateSquares(int[][] squares) {
-        int n = squares.length;
-        int m = 2 * n;
-        Event[] events = createEvents(squares, m);
-        double[] xsRaw = createXsRaw(squares, m);
-        Arrays.sort(events, Comparator.comparingDouble(e -> e.y));
-        double[] xs = compress(xsRaw);
-        double totalUnionArea = calculateTotalUnionArea(events, xs, m);
-        double target = totalUnionArea / 2.0;
-        return findSplitPoint(events, xs, m, target);
-    }
-
-    private Event[] createEvents(int[][] squares, int m) {
-        Event[] events = new Event[m];
-        int idx = 0;
-        for (int[] sq : squares) {
-            double x = sq[0];
-            double y = sq[1];
-            double l = sq[2];
-            double x2 = x + l;
-            double y2 = y + l;
-            events[idx++] = new Event(y, x, x2, 1);
-            events[idx++] = new Event(y2, x, x2, -1);
-        }
-        return events;
-    }
-
-    private double[] createXsRaw(int[][] squares, int m) {
-        double[] xsRaw = new double[m];
-        int xIdx = 0;
-        for (int[] sq : squares) {
-            double x = sq[0];
-            double l = sq[2];
-            xsRaw[xIdx++] = x;
-            xsRaw[xIdx++] = x + l;
-        }
-        return xsRaw;
-    }
-
-    private double calculateTotalUnionArea(Event[] events, double[] xs, int m) {
-        SegmentTree segTree = new SegmentTree(xs);
-        double totalUnionArea = 0.0;
-        double lastY = events[0].y;
-        int i = 0;
-        while (i < m) {
-            double curY = events[i].y;
-            if (curY > lastY) {
-                double unionX = segTree.query();
-                totalUnionArea += unionX * (curY - lastY);
-                lastY = curY;
-            }
-            while (i < m && events[i].y == curY) {
-                int[] indices = findIndices(xs, events[i]);
-                segTree.update(1, 0, xs.length - 1, indices[0], indices[1], events[i].type);
-                i++;
-            }
-        }
-        return totalUnionArea;
-    }
-
-    private double findSplitPoint(Event[] events, double[] xs, int m, double target) {
-        SegmentTree segTree = new SegmentTree(xs);
-        double lastY = events[0].y;
-        double cumArea = 0.0;
-        int i = 0;
-        while (i < m) {
-            double curY = events[i].y;
-            if (curY > lastY) {
-                double unionX = segTree.query();
-                double dy = curY - lastY;
-                if (cumArea + unionX * dy >= target - 1e-10) {
-                    return lastY + (target - cumArea) / unionX;
-                }
-                cumArea += unionX * dy;
-                lastY = curY;
-            }
-            while (i < m && events[i].y == curY) {
-                int[] indices = findIndices(xs, events[i]);
-                segTree.update(1, 0, xs.length - 1, indices[0], indices[1], events[i].type);
-                i++;
-            }
-        }
-        return lastY;
-    }
-
-    private int[] findIndices(double[] xs, Event event) {
-        int lIdx = Arrays.binarySearch(xs, event.x1);
-        if (lIdx < 0) {
-            lIdx = -lIdx - 1;
-        }
-        int rIdx = Arrays.binarySearch(xs, event.x2);
-        if (rIdx < 0) {
-            rIdx = -rIdx - 1;
-        }
-        return new int[] {lIdx, rIdx};
-    }
-
-    private double[] compress(double[] arr) {
-        Arrays.sort(arr);
-        int cnt = 1;
-        for (int i = 1; i < arr.length; i++) {
-            if (arr[i] != arr[i - 1]) {
-                cnt++;
-            }
-        }
-        double[] res = new double[cnt];
-        res[0] = arr[0];
-        int j = 1;
-        for (int i = 1; i < arr.length; i++) {
-            if (arr[i] != arr[i - 1]) {
-                res[j++] = arr[i];
-            }
-        }
-        return res;
-    }
-
-    private static class Event {
+    private static class Event implements Comparable<Event> {
         double y;
-        double x1;
-        double x2;
+        int x1;
+        int x2;
         int type;
 
-        Event(double y, double x1, double x2, int type) {
+        Event(double y, int x1, int x2, int type) {
             this.y = y;
             this.x1 = x1;
             this.x2 = x2;
             this.type = type;
         }
+
+        public int compareTo(Event other) {
+            return Double.compare(this.y, other.y);
+        }
+    }
+
+    private static class Segment {
+        double y1;
+        double y2;
+        double unionX;
+        double cumArea;
+
+        Segment(double y1, double y2, double unionX, double cumArea) {
+            this.y1 = y1;
+            this.y2 = y2;
+            this.unionX = unionX;
+            this.cumArea = cumArea;
+        }
     }
 
     private static class SegmentTree {
-        int n;
-        double[] tree;
         int[] count;
-        double[] xs;
+        double[] len;
+        int n;
+        int[] x;
 
-        SegmentTree(double[] xs) {
-            this.xs = xs;
-            this.n = xs.length;
-            tree = new double[4 * n];
+        SegmentTree(int[] x) {
+            this.x = x;
+            n = x.length - 1;
             count = new int[4 * n];
+            len = new double[4 * n];
         }
 
         void update(int idx, int l, int r, int ql, int qr, int val) {
-            if (qr <= l || ql >= r) {
+            if (qr < l || ql > r) {
                 return;
             }
             if (ql <= l && r <= qr) {
                 count[idx] += val;
             } else {
-                int mid = (l + r) >> 1;
-                update(idx << 1, l, mid, ql, qr, val);
-                update(idx << 1 | 1, mid, r, ql, qr, val);
+                int mid = (l + r) / 2;
+                update(2 * idx + 1, l, mid, ql, qr, val);
+                update(2 * idx + 2, mid + 1, r, ql, qr, val);
             }
             if (count[idx] > 0) {
-                tree[idx] = xs[r] - xs[l];
-            } else if (r - l == 1) {
-                tree[idx] = 0;
+                len[idx] = x[r + 1] - x[l];
             } else {
-                tree[idx] = tree[idx << 1] + tree[idx << 1 | 1];
+                if (l == r) {
+                    len[idx] = 0;
+                } else {
+                    len[idx] = len[2 * idx + 1] + len[2 * idx + 2];
+                }
             }
         }
 
+        void update(int ql, int qr, int val) {
+            update(0, 0, n - 1, ql, qr, val);
+        }
+
         double query() {
-            return tree[1];
+            return len[0];
+        }
+    }
+
+    public double separateSquares(int[][] squares) {
+        int n = squares.length;
+        Event[] events = new Event[2 * n];
+        int idx = 0;
+        List<Integer> xList = new ArrayList<>();
+        for (int[] s : squares) {
+            int x = s[0];
+            int y = s[1];
+            int l = s[2];
+            int x2 = x + l;
+            int y2 = y + l;
+            events[idx++] = new Event(y, x, x2, 1);
+            events[idx++] = new Event(y2, x, x2, -1);
+            xList.add(x);
+            xList.add(x2);
+        }
+        Arrays.sort(events);
+        int m = xList.size();
+        int[] xCords = new int[m];
+        for (int i = 0; i < m; i++) {
+            xCords[i] = xList.get(i);
+        }
+        Arrays.sort(xCords);
+        int uniqueCount = 0;
+        for (int i = 0; i < m; i++) {
+            if (i == 0 || xCords[i] != xCords[i - 1]) {
+                xCords[uniqueCount++] = xCords[i];
+            }
+        }
+        int[] x = Arrays.copyOf(xCords, uniqueCount);
+        SegmentTree segTree = new SegmentTree(x);
+        List<Segment> segments = new ArrayList<>();
+        double cumArea = 0.0;
+        double lastY = events[0].y;
+        int iEvent = 0;
+        while (iEvent < events.length) {
+            double currentY = events[iEvent].y;
+            double delta = currentY - lastY;
+            if (delta > 0) {
+                double unionX = segTree.query();
+                segments.add(new Segment(lastY, currentY, unionX, cumArea));
+                cumArea += unionX * delta;
+            }
+            while (iEvent < events.length && events[iEvent].y == currentY) {
+                Event e = events[iEvent];
+                int left = Arrays.binarySearch(x, e.x1);
+                int right = Arrays.binarySearch(x, e.x2);
+                if (left < right) {
+                    segTree.update(left, right - 1, e.type);
+                }
+                iEvent++;
+            }
+            lastY = currentY;
+        }
+        double totalArea = cumArea;
+        double target = totalArea / 2.0;
+        double answer;
+        for (Segment seg : segments) {
+            double segArea = seg.unionX * (seg.y2 - seg.y1);
+            if (seg.cumArea + segArea >= target) {
+                double needed = target - seg.cumArea;
+                answer = seg.y1 + needed / seg.unionX;
+                return answer;
+            }
         }
+        return lastY;
     }
 }

src/main/java/g3401_3500/s3455_shortest_matching_substring/Solution.java

@@ -1,6 +1,7 @@
 package g3401_3500.s3455_shortest_matching_substring;
 
-// #Hard #2025_02_16_Time_91_ms_(100.00%)_Space_55.37_MB_(100.00%)
+// #Hard #String #Binary_Search #Two_Pointers #String_Matching
+// #2025_02_18_Time_116_ms_(81.44%)_Space_55.28_MB_(88.02%)
 
 import java.util.ArrayList;
 import java.util.Arrays;