Fixed sonar

Author: javadev

src/main/java/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/Solution.java

@@ -2,11 +2,12 @@
 
 // #Medium #2025_05_11_Time_162_ms_(100.00%)_Space_61.48_MB_(100.00%)
 
-import java.util.Stack;
+import java.util.ArrayDeque;
+import java.util.Deque;
 
 public class Solution {
     public int minOperations(int[] nums) {
-        Stack<Integer> stack = new Stack<>();
+        Deque<Integer> stack = new ArrayDeque<>();
         stack.push(0);
         int res = 0;
         for (int a : nums) {

src/main/java/g3501_3600/s3544_subtree_inversion_sum/Solution.java

@@ -19,7 +19,8 @@ private long getTotalSum(int p, int cur) {
             }
             res += getTotalSum(cur, c);
         }
-        return totalSum[cur] = res;
+        totalSum[cur] = res;
+        return res;
     }
 
     private void add(long[][] a, long[][] b) {

src/main/java/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph/Solution.java

@@ -12,24 +12,43 @@ public class Solution {
     private int[] s;
 
     public long maxScore(int n, int[][] edges) {
+        initializeArrays(n);
+        processEdges(edges);
+        List<Integer> circles = new ArrayList<>();
+        List<Integer> chains = new ArrayList<>();
+        findParentsAndUpdateCircles();
+        collectCirclesAndChains(circles, chains);
+        Collections.sort(circles);
+        chains.sort((a, b) -> Integer.compare(b, a));
+        return calculateScore(n, circles, chains);
+    }
+
+    private void initializeArrays(int n) {
         p = new int[n];
         c = new boolean[n];
         s = new int[n];
         for (int i = 0; i < n; i++) {
             p[i] = i;
             s[i] = 1;
         }
+    }
+
+    private void processEdges(int[][] edges) {
         for (int[] ele : edges) {
             join(ele[0], ele[1]);
         }
-        List<Integer> circles = new ArrayList<>();
-        List<Integer> chains = new ArrayList<>();
+    }
+
+    private void findParentsAndUpdateCircles() {
         for (int i = 0; i < p.length; i++) {
             p[i] = findParent(i);
             if (c[i]) {
                 c[p[i]] = true;
             }
         }
+    }
+
+    private void collectCirclesAndChains(List<Integer> circles, List<Integer> chains) {
         for (int i = 0; i < p.length; i++) {
             if (p[i] == i) {
                 int size = s[i];
@@ -40,58 +59,75 @@ public long maxScore(int n, int[][] edges) {
                 }
             }
         }
-        Collections.sort(circles);
-        chains.sort((a, b) -> Integer.compare(b, a));
+    }
+
+    private long calculateScore(int n, List<Integer> circles, List<Integer> chains) {
         long ret = 0;
         int start = n;
+        ret += processCircles(circles, start);
+        start = n - getTotalCircleSize(circles);
+        ret += processChains(chains, start);
+        return ret;
+    }
+
+    private int getTotalCircleSize(List<Integer> circles) {
+        return circles.stream().mapToInt(Integer::intValue).sum();
+    }
+
+    private long processCircles(List<Integer> circles, int start) {
+        long ret = 0;
         for (int size : circles) {
             if (size == 1) {
                 continue;
             }
-            int[] temp = new int[size];
-            int ptr1 = 0;
-            int ptr2 = size - 1;
-            int curStart = start - size + 1;
-            for (int i = 0; i < size; i++) {
-                if (i % 2 == 0) {
-                    temp[ptr1++] = curStart + i;
-                } else {
-                    temp[ptr2--] = curStart + i;
-                }
-            }
-            long pro = 0;
-            for (int i = 1; i < size; i++) {
-                pro += (long) temp[i] * temp[i - 1];
-            }
-            pro += (long) temp[0] * temp[size - 1];
+            int[] temp = createTempArray(size, start);
+            long pro = calculateProduct(temp, true);
             ret += pro;
             start = start - size;
         }
+        return ret;
+    }
+
+    private long processChains(List<Integer> chains, int start) {
+        long ret = 0;
         for (int size : chains) {
             if (size == 1) {
                 continue;
             }
-            int[] temp = new int[size];
-            int ptr1 = 0;
-            int ptr2 = size - 1;
-            int curStart = start - size + 1;
-            for (int i = 0; i < size; i++) {
-                if (i % 2 == 0) {
-                    temp[ptr1++] = curStart + i;
-                } else {
-                    temp[ptr2--] = curStart + i;
-                }
-            }
-            long pro = 0;
-            for (int i = 1; i < size; i++) {
-                pro += (long) temp[i] * temp[i - 1];
-            }
+            int[] temp = createTempArray(size, start);
+            long pro = calculateProduct(temp, false);
             ret += pro;
             start = start - size;
         }
         return ret;
     }
 
+    private int[] createTempArray(int size, int start) {
+        int[] temp = new int[size];
+        int ptr1 = 0;
+        int ptr2 = size - 1;
+        int curStart = start - size + 1;
+        for (int i = 0; i < size; i++) {
+            if (i % 2 == 0) {
+                temp[ptr1++] = curStart + i;
+            } else {
+                temp[ptr2--] = curStart + i;
+            }
+        }
+        return temp;
+    }
+
+    private long calculateProduct(int[] temp, boolean isCircle) {
+        long pro = 0;
+        for (int i = 1; i < temp.length; i++) {
+            pro += (long) temp[i] * temp[i - 1];
+        }
+        if (isCircle) {
+            pro += (long) temp[0] * temp[temp.length - 1];
+        }
+        return pro;
+    }
+
     private int findParent(int x) {
         if (p[x] != x) {
             p[x] = findParent(p[x]);