Fixed style

Author: javadev

src/main/java/g3101_3200/s3112_minimum_time_to_visit_disappearing_nodes/Solution.java

@@ -10,7 +10,10 @@ public int[] minimumTime(int n, int[][] edges, int[] disappear) {
         int[] dist = new int[n];
         Arrays.fill(dist, Integer.MAX_VALUE);
         boolean exit = false;
-        int i, src, dest, cost;
+        int i;
+        int src;
+        int dest;
+        int cost;
         dist[0] = 0;
         for (i = 0; i < n && !exit; ++i) {
             exit = true;

src/main/java/g3101_3200/s3113_find_the_number_of_subarrays_where_boundary_elements_are_maximum/Solution.java

@@ -11,7 +11,9 @@ public long numberOfSubarrays(int[] nums) {
         long res = 0;
         for (int a : nums) {
             while (!stack.isEmpty() && stack.peek()[0] < a) stack.pop();
-            if (stack.isEmpty() || stack.peek()[0] != a) stack.push(new int[] {a, 0});
+            if (stack.isEmpty() || stack.peek()[0] != a) {
+                stack.push(new int[] {a, 0});
+            }
             res += ++stack.peek()[1];
         }
         return res;

src/main/java/g3101_3200/s3116_kth_smallest_amount_with_single_denomination_combination/Solution.java

@@ -8,7 +8,9 @@
 public class Solution {
     public long findKthSmallest(int[] coins, int k) {
         int minC = Integer.MAX_VALUE;
-        for (int c : coins) minC = Math.min(minC, c);
+        for (int c : coins) {
+            minC = Math.min(minC, c);
+        }
         long[] cc = coins(coins);
         long max = (long) minC * k;
         long min = max / coins.length;
@@ -28,7 +30,9 @@ public long findKthSmallest(int[] coins, int k) {
 
     private long count(long[] coins, long v) {
         long r = 0;
-        for (long c : coins) r += v / c;
+        for (long c : coins) {
+            r += v / c;
+        }
         return r;
     }
 
@@ -39,7 +43,9 @@ private long[] coins(int[] coins) {
         for (int i = 1; i < coins.length; i++) {
             final int c = coins[i];
             for (int j = 0; j < len; j++) {
-                if (c % coins[j] == 0) continue a;
+                if (c % coins[j] == 0) {
+                    continue a;
+                }
             }
             coins[len++] = c;
         }

src/main/java/g3101_3200/s3117_minimum_sum_of_values_by_dividing_array/Solution.java

@@ -14,10 +14,13 @@ public int minimumValueSum(int[] nums, int[] andValues) {
         Arrays.fill(dp, INF);
         dp[0] = 0;
         for (int target : andValues) {
-            int sum = INF, minSum = INF, rightSum = INF;
+            int sum = INF;
+            int minSum = INF;
+            int rightSum = INF;
             int[] leftSum = new int[n + 1];
             leftSum[0] = INF;
-            int left = 0, right = 0;
+            int left = 0;
+            int right = 0;
             int[] nextdp = new int[n + 1];
             nextdp[0] = INF;
             for (int i = 0; i < n; ++i) {

src/main/java/g3101_3200/s3120_count_the_number_of_special_characters_i/Solution.java

@@ -4,15 +4,20 @@
 
 public class Solution {
     public int numberOfSpecialChars(String word) {
-        int a[] = new int[26];
-        int b[] = new int[26];
+        int[] a = new int[26];
+        int[] b = new int[26];
         int ans = 0;
         for (char c : word.toCharArray()) {
-            if (c >= 'a' && c <= 'z') a[c - 'a']++;
-            else b[c - 'A']++;
+            if (c >= 'a' && c <= 'z') {
+                a[c - 'a']++;
+            } else {
+                b[c - 'A']++;
+            }
         }
         for (int i = 0; i < 26; i++) {
-            if (a[i] != 0 && b[i] != 0) ans++;
+            if (a[i] != 0 && b[i] != 0) {
+                ans++;
+            }
         }
         return ans;
     }

src/main/java/g3101_3200/s3123_find_edges_in_shortest_paths/Solution.java

@@ -26,9 +26,10 @@ public boolean[] findAnswer(int n, int[][] edges) {
         weight = new int[m << 1];
         next = new int[m << 1];
         head = new int[n];
-        for (int i = 0; i < n; ++i) head[i] = -1;
+        for (int i = 0; i < n; ++i) {
+            head[i] = -1;
+        }
         index = 0;
-
         for (int[] edge : edges) {
             int u = edge[0], v = edge[1], w = edge[2];
             add(u, v, w);
@@ -68,7 +69,9 @@ public boolean[] findAnswer(int n, int[][] edges) {
 
     private void dfs(long[] distances, int u, int pre, boolean[] ans) {
         for (int index = head[u]; index != -1; index = next[index]) {
-            int v = edge[index], w = weight[index], i = index >> 1;
+            int v = edge[index];
+            int w = weight[index];
+            int i = index >> 1;
             if (distances[v] + w != distances[u]) {
                 continue;
             }