Fixed sonar

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]);