Fixed sonar

Author: javadev

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

@@ -1,6 +1,6 @@
 package g3401_3500.s3454_separate_squares_ii;
 
-// #Hard #2025_02_16_Time_243_ms_(100.00%)_Space_76.06_MB_(100.00%)
+// #Hard #2025_02_16_Time_246_ms_(100.00%)_Space_79.98_MB_(100.00%)
 
 import java.util.Arrays;
 import java.util.Comparator;
@@ -9,86 +9,99 @@ 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];
-        double[] xsRaw = new double[m];
         int idx = 0;
-        int xIdx = 0;
         for (int[] sq : squares) {
-            // Each square gives a rectangle [x, x+l] x [y, y+l]
             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++] = x2;
+            xsRaw[xIdx++] = x + l;
         }
-        // Sort events by their y-coordinate (they are exact integers in double format)
-        Arrays.sort(events, Comparator.comparingDouble(e -> e.y));
-        // Compress x-coordinates
-        double[] xs = compress(xsRaw);
-        // FIRST SWEEP: compute total union area.
+        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;
-        for (int i = 0; i < m; ) {
+        int i = 0;
+        while (i < m) {
             double curY = events[i].y;
             if (curY > lastY) {
                 double unionX = segTree.query();
                 totalUnionArea += unionX * (curY - lastY);
                 lastY = curY;
             }
-            // Process all events at y == curY
             while (i < m && events[i].y == curY) {
-                int lIdx = Arrays.binarySearch(xs, events[i].x1);
-                if (lIdx < 0) {
-                    lIdx = -lIdx - 1;
-                }
-                int rIdx = Arrays.binarySearch(xs, events[i].x2);
-                if (rIdx < 0) {
-                    rIdx = -rIdx - 1;
-                }
-                segTree.update(1, 0, xs.length - 1, lIdx, rIdx, events[i].type);
+                int[] indices = findIndices(xs, events[i]);
+                segTree.update(1, 0, xs.length - 1, indices[0], indices[1], events[i].type);
                 i++;
             }
         }
-        double target = totalUnionArea / 2.0;
-        // SECOND SWEEP: find minimal y such that cumulative union area reaches target.
-        // Reinitialize segment tree for a fresh sweep.
-        segTree = new SegmentTree(xs);
-        lastY = events[0].y;
+        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;
         for (int i = 0; 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) {
-                    // The answer lies in this interval.
                     return lastY + (target - cumArea) / unionX;
                 }
                 cumArea += unionX * dy;
                 lastY = curY;
             }
             while (i < m && events[i].y == curY) {
-                int lIdx = Arrays.binarySearch(xs, events[i].x1);
-                if (lIdx < 0) {
-                    lIdx = -lIdx - 1;
-                }
-                int rIdx = Arrays.binarySearch(xs, events[i].x2);
-                if (rIdx < 0) {
-                    rIdx = -rIdx - 1;
-                }
-                segTree.update(1, 0, xs.length - 1, lIdx, rIdx, events[i].type);
+                int[] indices = findIndices(xs, events[i]);
+                segTree.update(1, 0, xs.length - 1, indices[0], indices[1], events[i].type);
                 i++;
             }
         }
         return lastY;
     }
 
-    // Compress an array of doubles into a sorted array of unique values.
+    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;
@@ -108,12 +121,10 @@ private double[] compress(double[] arr) {
         return res;
     }
 
-    // Event class for the sweep-line.
     private static class Event {
         double y;
         double x1;
         double x2;
-        // +1 for adding an interval; -1 for removing.
         int type;
 
         Event(double y, double x1, double x2, int type) {
@@ -124,26 +135,19 @@ private static class Event {
         }
     }
 
-    // Segment Tree for maintaining the union length over the x-axis.
     private static class SegmentTree {
         int n;
-        // Covered length of the segment.
         double[] tree;
-        // Coverage count for the segment.
         int[] count;
-        // The compressed x-coordinates.
         double[] xs;
 
         SegmentTree(double[] xs) {
             this.xs = xs;
             this.n = xs.length;
-            // Allocate 4*n size arrays.
             tree = new double[4 * n];
             count = new int[4 * n];
         }
 
-        // Update the range [ql, qr) with value 'val'.
-        // The current node covers indices [l, r) in xs.
         void update(int idx, int l, int r, int ql, int qr, int val) {
             if (qr <= l || ql >= r) {
                 return;
@@ -164,7 +168,6 @@ void update(int idx, int l, int r, int ql, int qr, int val) {
             }
         }
 
-        // Query the current total union length.
         double query() {
             return tree[1];
         }