Fixed sonar

javadev · javadev · commit 7daa49caf0b3 · 2024-08-06T14:05:07.000+03:00
diff --git a/src/main/java/g3201_3300/s3238_find_the_number_of_winning_players/Solution.java b/src/main/java/g3201_3300/s3238_find_the_number_of_winning_players/Solution.java
@@ -2,7 +2,7 @@
 
 // #Easy #Array #Hash_Table #Counting #2024_08_06_Time_1_ms_(100.00%)_Space_44.5_MB_(99.46%)
 
-@SuppressWarnings("unused")
+@SuppressWarnings({"unused", "java:S1172"})
 public class Solution {
     public int winningPlayerCount(int n, int[][] pick) {
         int[][] dp = new int[11][11];
diff --git a/src/main/java/g3201_3300/s3241_time_taken_to_mark_all_nodes/Solution.java b/src/main/java/g3201_3300/s3241_time_taken_to_mark_all_nodes/Solution.java
@@ -25,10 +25,12 @@ public int[] timeTaken(int[][] edges) {
             int v = edges[i][1];
             nxt[j] = head[u];
             head[u] = j;
-            to[j++] = v;
+            to[j] = v;
+            j++;
             nxt[j] = head[v];
             head[v] = j;
-            to[j++] = u;
+            to[j] = u;
+            j++;
         }
         last = new int[n];
         lastNo = new int[n];
@@ -41,7 +43,9 @@ public int[] timeTaken(int[][] edges) {
     }
 
     private void dfs2(int f, int u, int preLast) {
-        for (int e = head[u], v; e != -1; e = nxt[e]) {
+        int e = head[u];
+        int v;
+        while (e != -1) {
             v = to[e];
             if (f != v) {
                 int pl;
@@ -53,11 +57,14 @@ private void dfs2(int f, int u, int preLast) {
                 ans[v] = Math.max(ans[v], pl);
                 dfs2(u, v, pl);
             }
+            e = nxt[e];
         }
     }
 
     private void dfs(int f, int u) {
-        for (int e = head[u], v; e != -1; e = nxt[e]) {
+        int e = head[u];
+        int v;
+        while (e != -1) {
             v = to[e];
             if (f != v) {
                 dfs(u, v);
@@ -70,6 +77,7 @@ private void dfs(int f, int u) {
                     second[u] = t;
                 }
             }
+            e = nxt[e];
         }
     }
 }
diff --git a/src/main/java/g3201_3300/s3245_alternating_groups_iii/Solution.java b/src/main/java/g3201_3300/s3245_alternating_groups_iii/Solution.java
@@ -14,7 +14,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre != -1 && pre < n && --fs[nex - pre] == 0) {
-                ff.unset(nex - pre);
+                ff.unsetPos(nex - pre);
             }
         }
         if (lst.get(ind)) {
@@ -24,7 +24,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre != -1 && pre < n && --fs[nex - pre] == 0) {
-                ff.unset(nex - pre);
+                ff.unsetPos(nex - pre);
             }
         }
         if (lst.get(ind + 1)) {
@@ -34,17 +34,17 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre != -1 && pre < n && --fs[nex - pre] == 0) {
-                ff.unset(nex - pre);
+                ff.unsetPos(nex - pre);
             }
         }
-        lst.unset(ind);
-        lst.unset(ind + 1);
+        lst.unsetPos(ind);
+        lst.unsetPos(ind + 1);
         c[ind] ^= 1;
         if (ind > 0 && c[ind] != c[ind - 1]) {
-            lst.set(ind);
+            lst.setPos(ind);
         }
         if (ind + 1 < c.length && c[ind + 1] != c[ind]) {
-            lst.set(ind + 1);
+            lst.setPos(ind + 1);
         }
         if (ind > 0) {
             int pre = lst.prev(ind - 1);
@@ -53,7 +53,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre != -1 && pre < n && ++fs[nex - pre] == 1) {
-                ff.set(nex - pre);
+                ff.setPos(nex - pre);
             }
         }
         if (lst.get(ind)) {
@@ -63,7 +63,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre < n && ++fs[nex - pre] == 1) {
-                ff.set(nex - pre);
+                ff.setPos(nex - pre);
             }
         }
         if (lst.get(ind + 1)) {
@@ -73,7 +73,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {
                 nex = 2 * n;
             }
             if (pre < n && ++fs[nex - pre] == 1) {
-                ff.set(nex - pre);
+                ff.setPos(nex - pre);
             }
         }
     }
@@ -87,7 +87,7 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {
         LST lst = new LST(2 * n + 3);
         for (int i = 1; i < 2 * n; i++) {
             if (c[i] != c[i - 1]) {
-                lst.set(i);
+                lst.setPos(i);
             }
         }
         int[] fs = new int[2 * n + 1];
@@ -99,7 +99,7 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {
                     ne = 2 * n;
                 }
                 fs[ne - i]++;
-                ff.set(ne - i);
+                ff.setPos(ne - i);
             }
         }
         List<Integer> ans = new ArrayList<>();
@@ -135,26 +135,29 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {
     }
 
     private static class LST {
-        public long[][] set;
-        public int n;
+        private long[][] set;
+        private int n;
 
         public LST(int n) {
             this.n = n;
             int d = 1;
-            {
-                int m = n;
-                while (m > 1) {
-                    m >>>= 6;
-                    d++;
-                }
-            }
+            d = getD(n, d);
             set = new long[d][];
             for (int i = 0, m = n >>> 6; i < d; i++, m >>>= 6) {
                 set[i] = new long[m + 1];
             }
         }
 
-        public LST set(int pos) {
+        private int getD(int n, int d) {
+            int m = n;
+            while (m > 1) {
+                m >>>= 6;
+                d++;
+            }
+            return d;
+        }
+
+        public LST setPos(int pos) {
             if (pos >= 0 && pos < n) {
                 for (int i = 0; i < set.length; i++, pos >>>= 6) {
                     set[i][pos >>> 6] |= 1L << pos;
@@ -163,7 +166,7 @@ public LST set(int pos) {
             return this;
         }
 
-        public LST unset(int pos) {
+        public LST unsetPos(int pos) {
             if (pos >= 0 && pos < n) {
                 for (int i = 0;
                         i < set.length && (i == 0 || set[i - 1][pos] == 0L);
@@ -179,7 +182,8 @@ public boolean get(int pos) {
         }
 
         public int prev(int pos) {
-            for (int i = 0; i < set.length && pos >= 0; i++, pos >>>= 6, pos--) {
+            int i = 0;
+            while (i < set.length && pos >= 0) {
                 int pre = prev(set[i][pos >>> 6], pos & 63);
                 if (pre != -1) {
                     pos = pos >>> 6 << 6 | pre;
@@ -188,6 +192,9 @@ public int prev(int pos) {
                     }
                     return pos;
                 }
+                i++;
+                pos >>>= 6;
+                pos--;
             }
             return -1;
         }

Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,12 @@ public int[] timeTaken(int[][] edges) {`
`25`	`25`	`int v = edges[i][1];`
`26`	`26`	`nxt[j] = head[u];`
`27`	`27`	`head[u] = j;`
`28`		`- to[j++] = v;`
	`28`	`+ to[j] = v;`
	`29`	`+ j++;`
`29`	`30`	`nxt[j] = head[v];`
`30`	`31`	`head[v] = j;`
`31`		`- to[j++] = u;`
	`32`	`+ to[j] = u;`
	`33`	`+ j++;`
`32`	`34`	`}`
`33`	`35`	`last = new int[n];`
`34`	`36`	`lastNo = new int[n];`
`@@ -41,7 +43,9 @@ public int[] timeTaken(int[][] edges) {`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`private void dfs2(int f, int u, int preLast) {`
`44`		`- for (int e = head[u], v; e != -1; e = nxt[e]) {`
	`46`	`+ int e = head[u];`
	`47`	`+ int v;`
	`48`	`+ while (e != -1) {`
`45`	`49`	`v = to[e];`
`46`	`50`	`if (f != v) {`
`47`	`51`	`int pl;`
`@@ -53,11 +57,14 @@ private void dfs2(int f, int u, int preLast) {`
`53`	`57`	`ans[v] = Math.max(ans[v], pl);`
`54`	`58`	`dfs2(u, v, pl);`
`55`	`59`	`}`
	`60`	`+ e = nxt[e];`
`56`	`61`	`}`
`57`	`62`	`}`
`58`	`63`
`59`	`64`	`private void dfs(int f, int u) {`
`60`		`- for (int e = head[u], v; e != -1; e = nxt[e]) {`
	`65`	`+ int e = head[u];`
	`66`	`+ int v;`
	`67`	`+ while (e != -1) {`
`61`	`68`	`v = to[e];`
`62`	`69`	`if (f != v) {`
`63`	`70`	`dfs(u, v);`
`@@ -70,6 +77,7 @@ private void dfs(int f, int u) {`
`70`	`77`	`second[u] = t;`
`71`	`78`	`}`
`72`	`79`	`}`
	`80`	`+ e = nxt[e];`
`73`	`81`	`}`
`74`	`82`	`}`
`75`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`14`	`14`	`nex = 2 * n;`
`15`	`15`	`}`
`16`	`16`	`if (pre != -1 && pre < n && --fs[nex - pre] == 0) {`
`17`		`- ff.unset(nex - pre);`
	`17`	`+ ff.unsetPos(nex - pre);`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`	`if (lst.get(ind)) {`
`@@ -24,7 +24,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`24`	`24`	`nex = 2 * n;`
`25`	`25`	`}`
`26`	`26`	`if (pre != -1 && pre < n && --fs[nex - pre] == 0) {`
`27`		`- ff.unset(nex - pre);`
	`27`	`+ ff.unsetPos(nex - pre);`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`	`if (lst.get(ind + 1)) {`
`@@ -34,17 +34,17 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`34`	`34`	`nex = 2 * n;`
`35`	`35`	`}`
`36`	`36`	`if (pre != -1 && pre < n && --fs[nex - pre] == 0) {`
`37`		`- ff.unset(nex - pre);`
	`37`	`+ ff.unsetPos(nex - pre);`
`38`	`38`	`}`
`39`	`39`	`}`
`40`		`- lst.unset(ind);`
`41`		`- lst.unset(ind + 1);`
	`40`	`+ lst.unsetPos(ind);`
	`41`	`+ lst.unsetPos(ind + 1);`
`42`	`42`	`c[ind] ^= 1;`
`43`	`43`	`if (ind > 0 && c[ind] != c[ind - 1]) {`
`44`		`- lst.set(ind);`
	`44`	`+ lst.setPos(ind);`
`45`	`45`	`}`
`46`	`46`	`if (ind + 1 < c.length && c[ind + 1] != c[ind]) {`
`47`		`- lst.set(ind + 1);`
	`47`	`+ lst.setPos(ind + 1);`
`48`	`48`	`}`
`49`	`49`	`if (ind > 0) {`
`50`	`50`	`int pre = lst.prev(ind - 1);`
`@@ -53,7 +53,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`53`	`53`	`nex = 2 * n;`
`54`	`54`	`}`
`55`	`55`	`if (pre != -1 && pre < n && ++fs[nex - pre] == 1) {`
`56`		`- ff.set(nex - pre);`
	`56`	`+ ff.setPos(nex - pre);`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`	`if (lst.get(ind)) {`
`@@ -63,7 +63,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`63`	`63`	`nex = 2 * n;`
`64`	`64`	`}`
`65`	`65`	`if (pre < n && ++fs[nex - pre] == 1) {`
`66`		`- ff.set(nex - pre);`
	`66`	`+ ff.setPos(nex - pre);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`	`if (lst.get(ind + 1)) {`
`@@ -73,7 +73,7 @@ private void go(int ind, LST lst, int[] fs, int n, LST ff, int[] c) {`
`73`	`73`	`nex = 2 * n;`
`74`	`74`	`}`
`75`	`75`	`if (pre < n && ++fs[nex - pre] == 1) {`
`76`		`- ff.set(nex - pre);`
	`76`	`+ ff.setPos(nex - pre);`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`	`}`
`@@ -87,7 +87,7 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {`
`87`	`87`	`LST lst = new LST(2 * n + 3);`
`88`	`88`	`for (int i = 1; i < 2 * n; i++) {`
`89`	`89`	`if (c[i] != c[i - 1]) {`
`90`		`- lst.set(i);`
	`90`	`+ lst.setPos(i);`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`int[] fs = new int[2 * n + 1];`
`@@ -99,7 +99,7 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {`
`99`	`99`	`ne = 2 * n;`
`100`	`100`	`}`
`101`	`101`	`fs[ne - i]++;`
`102`		`- ff.set(ne - i);`
	`102`	`+ ff.setPos(ne - i);`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`List<Integer> ans = new ArrayList<>();`
`@@ -135,26 +135,29 @@ public List<Integer> numberOfAlternatingGroups(int[] colors, int[][] queries) {`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`private static class LST {`
`138`		`- public long[][] set;`
`139`		`- public int n;`
	`138`	`+ private long[][] set;`
	`139`	`+ private int n;`
`140`	`140`
`141`	`141`	`public LST(int n) {`
`142`	`142`	`this.n = n;`
`143`	`143`	`int d = 1;`
`144`		`- {`
`145`		`- int m = n;`
`146`		`- while (m > 1) {`
`147`		`- m >>>= 6;`
`148`		`- d++;`
`149`		`- }`
`150`		`- }`
	`144`	`+ d = getD(n, d);`
`151`	`145`	`set = new long[d][];`
`152`	`146`	`for (int i = 0, m = n >>> 6; i < d; i++, m >>>= 6) {`
`153`	`147`	`set[i] = new long[m + 1];`
`154`	`148`	`}`
`155`	`149`	`}`
`156`	`150`
`157`		`- public LST set(int pos) {`
	`151`	`+ private int getD(int n, int d) {`
	`152`	`+ int m = n;`
	`153`	`+ while (m > 1) {`
	`154`	`+ m >>>= 6;`
	`155`	`+ d++;`
	`156`	`+ }`
	`157`	`+ return d;`
	`158`	`+ }`
	`159`	`+`
	`160`	`+ public LST setPos(int pos) {`
`158`	`161`	`if (pos >= 0 && pos < n) {`
`159`	`162`	`for (int i = 0; i < set.length; i++, pos >>>= 6) {`
`160`	`163`	`set[i][pos >>> 6] \|= 1L << pos;`
`@@ -163,7 +166,7 @@ public LST set(int pos) {`
`163`	`166`	`return this;`
`164`	`167`	`}`
`165`	`168`
`166`		`- public LST unset(int pos) {`
	`169`	`+ public LST unsetPos(int pos) {`
`167`	`170`	`if (pos >= 0 && pos < n) {`
`168`	`171`	`for (int i = 0;`
`169`	`172`	`i < set.length && (i == 0 \|\| set[i - 1][pos] == 0L);`
`@@ -179,7 +182,8 @@ public boolean get(int pos) {`
`179`	`182`	`}`
`180`	`183`
`181`	`184`	`public int prev(int pos) {`
`182`		`- for (int i = 0; i < set.length && pos >= 0; i++, pos >>>= 6, pos--) {`
	`185`	`+ int i = 0;`
	`186`	`+ while (i < set.length && pos >= 0) {`
`183`	`187`	`int pre = prev(set[i][pos >>> 6], pos & 63);`
`184`	`188`	`if (pre != -1) {`
`185`	`189`	`pos = pos >>> 6 << 6 \| pre;`
`@@ -188,6 +192,9 @@ public int prev(int pos) {`
`188`	`192`	`}`
`189`	`193`	`return pos;`
`190`	`194`	`}`
	`195`	`+ i++;`
	`196`	`+ pos >>>= 6;`
	`197`	`+ pos--;`
`191`	`198`	`}`
`192`	`199`	`return -1;`
`193`	`200`	`}`