Updated tags

Author: javadev

src/main/java/g3501_3600/s3556_sum_of_largest_prime_substrings/Solution.java

@@ -1,45 +1,65 @@
 package g3501_3600.s3556_sum_of_largest_prime_substrings;
 
-// #Medium #2025_05_25_Time_21_ms_(100.00%)_Space_42.82_MB_(100.00%)
+// #Medium #String #Hash_Table #Math #Sorting #Number_Theory
+// #2025_05_27_Time_7_ms_(99.93%)_Space_42.77_MB_(98.34%)
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Set;
 
 public class Solution {
     public long sumOfLargestPrimes(String s) {
-        Set<Long> primeSet = new HashSet<>();
+        Set<Long> set = new HashSet<>();
         int n = s.length();
-        for (int i = 0; i < n; ++i) {
-            long temp = 0;
-            for (int j = i; j < n; ++j) {
-                temp = temp * 10 + (s.charAt(j) - '0');
-                if (isPrime(temp)) {
-                    primeSet.add(temp);
+        long first = -1;
+        long second = -1;
+        long third = -1;
+        for (int i = 0; i < n; i++) {
+            long num = 0;
+            for (int j = i; j < n; j++) {
+                num = num * 10 + (s.charAt(j) - '0');
+                if (i != j && s.charAt(i) == '0') {
+                    break;
+                }
+                if (isPrime(num) && !set.contains(num)) {
+                    set.add(num);
+                    if (num > first) {
+                        third = second;
+                        second = first;
+                        first = num;
+                    } else if (num > second) {
+                        third = second;
+                        second = num;
+                    } else if (num > third) {
+                        third = num;
+                    }
                 }
             }
         }
-        List<Long> primes = new ArrayList<>(primeSet);
-        Collections.sort(primes);
-        int m = primes.size();
-        if (m < 3) {
-            long sum = 0;
-            for (long p : primes) {
-                sum += p;
-            }
-            return sum;
+        long sum = 0;
+        if (first != -1) {
+            sum += first;
+        }
+        if (second != -1) {
+            sum += second;
+        }
+        if (third != -1) {
+            sum += third;
         }
-        return primes.get(m - 1) + primes.get(m - 2) + primes.get(m - 3);
+        return sum;
     }
 
-    private boolean isPrime(long n) {
-        if (n < 2) {
+    public boolean isPrime(long num) {
+        if (num <= 1) {
+            return false;
+        }
+        if (num == 2 || num == 3) {
+            return true;
+        }
+        if (num % 2 == 0 || num % 3 == 0) {
             return false;
         }
-        for (long i = 2; i * i <= n; ++i) {
-            if (n % i == 0) {
+        for (long i = 5; i * i <= num; i += 6) {
+            if (num % i == 0 || num % (i + 2) == 0) {
                 return false;
             }
         }

src/main/java/g3501_3600/s3557_find_maximum_number_of_non_intersecting_substrings/Solution.java

@@ -1,32 +1,24 @@
 package g3501_3600.s3557_find_maximum_number_of_non_intersecting_substrings;
 
-// #Medium #2025_05_25_Time_103_ms_(100.00%)_Space_54.87_MB_(100.00%)
+// #Medium #String #Hash_Table #Dynamic_Programming #Greedy
+// #2025_05_27_Time_15_ms_(84.54%)_Space_45.82_MB_(91.39%)
 
-import java.util.Deque;
-import java.util.LinkedList;
+import java.util.Arrays;
 
-@SuppressWarnings("unchecked")
 public class Solution {
     public int maxSubstrings(String s) {
-        Deque<Integer>[] last = new LinkedList[26];
-        for (int k = 0; k < 26; k++) {
-            last[k] = new LinkedList<>();
-        }
-        int n = s.length();
-        int[] dp = new int[n + 1];
-        for (int i = 0; i < n; i++) {
-            int c = s.charAt(i) - 'a';
-            dp[i + 1] = dp[i];
-            for (int j : last[c]) {
-                if (i - j + 1 >= 4) {
-                    dp[i + 1] = Math.max(dp[i + 1], dp[j] + 1);
-                }
-            }
-            last[c].addLast(i);
-            if (last[c].size() > 4) {
-                last[c].removeFirst();
+        int[] prev = new int[26];
+        int r = 0;
+        Arrays.fill(prev, -1);
+        for (int i = 0; i < s.length(); ++i) {
+            int j = s.charAt(i) - 'a';
+            if (prev[j] != -1 && i - prev[j] + 1 >= 4) {
+                ++r;
+                Arrays.fill(prev, -1);
+            } else if (prev[j] == -1) {
+                prev[j] = i;
             }
         }
-        return dp[n];
+        return r;
     }
 }

src/main/java/g3501_3600/s3558_number_of_ways_to_assign_edge_weights_i/Solution.java

@@ -1,67 +1,50 @@
 package g3501_3600.s3558_number_of_ways_to_assign_edge_weights_i;
 
-// #Medium #2025_05_25_Time_118_ms_(100.00%)_Space_122.30_MB_(100.00%)
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
+// #Medium #Math #Tree #Depth_First_Search #2025_05_27_Time_12_ms_(100.00%)_Space_106.62_MB_(76.01%)
 
 public class Solution {
-    private static final int MOD = (int) 1e9 + 7;
+    private static int mod = (int) 1e9 + 7;
+    private static long[] pow2 = new long[100001];
 
     public int assignEdgeWeights(int[][] edges) {
-        int n = edges.length + 1;
-        List<List<Integer>> adj = new ArrayList<>();
-        for (int i = 0; i <= n; i++) {
-            adj.add(new ArrayList<>());
-        }
-        for (int[] i : edges) {
-            adj.get(i[0]).add(i[1]);
-            adj.get(i[1]).add(i[0]);
-        }
-        int[] l = new int[n + 1];
-        int max = 0;
-        Arrays.fill(l, -1);
-        Queue<int[]> q = new LinkedList<>();
-        q.offer(new int[] {1, 0});
-        l[1] = 0;
-        while (!q.isEmpty()) {
-            int curr = q.peek()[0];
-            int level = q.peek()[1];
-            if (l[max] < l[curr]) {
-                max = curr;
-            }
-            q.remove();
-            for (int next : adj.get(curr)) {
-                if (l[next] != -1) {
-                    continue;
-                }
-                q.offer(new int[] {next, level + 1});
-                l[next] = level + 1;
+        if (pow2[0] == 0) {
+            pow2[0] = 1;
+            for (int i = 1; i < pow2.length; i++) {
+                pow2[i] = (pow2[i - 1] << 1) % mod;
             }
         }
-        int[][] dp = new int[l[max]][2];
-        for (int[] i : dp) {
-            Arrays.fill(i, -1);
+        int n = edges.length + 1;
+        int[] adj = new int[n + 1];
+        int[] degrees = new int[n + 1];
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            adj[u] += v;
+            adj[v] += u;
+            degrees[u]++;
+            degrees[v]++;
         }
-        return solve(0, 0, dp);
-    }
-
-    private int solve(int ind, int odd, int[][] dp) {
-        if (ind == dp.length) {
-            if (odd == 1) {
-                return 1;
-            } else {
-                return 0;
+        int[] que = new int[n];
+        int write = 0;
+        int read = 0;
+        for (int i = 2; i <= n; ++i) {
+            if (degrees[i] == 1) {
+                que[write++] = i;
             }
         }
-        if (dp[ind][odd] != -1) {
-            return dp[ind][odd];
+        int distance = 0;
+        while (read < write) {
+            distance++;
+            int size = write - read;
+            while (size-- > 0) {
+                int v = que[read++];
+                int u = adj[v];
+                adj[u] -= v;
+                if (--degrees[u] == 1 && u != 1) {
+                    que[write++] = u;
+                }
+            }
         }
-        dp[ind][odd] =
-                (solve(ind + 1, odd, dp) % MOD + solve(ind + 1, (odd + 1) % 2, dp) % MOD) % MOD;
-        return dp[ind][odd];
+        return (int) pow2[distance - 1];
     }
 }

src/main/java/g3501_3600/s3559_number_of_ways_to_assign_edge_weights_ii/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3559_number_of_ways_to_assign_edge_weights_ii;
 
-// #Hard #2025_05_25_Time_135_ms_(100.00%)_Space_119.27_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Math #Tree #Depth_First_Search
+// #2025_05_27_Time_138_ms_(64.66%)_Space_133.20_MB_(11.56%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3501_3600/s3560_find_minimum_log_transportation_cost/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3560_find_minimum_log_transportation_cost;
 
-// #Easy #2025_05_25_Time_0_ms_(100.00%)_Space_41.10_MB_(56.75%)
+// #Easy #Math #2025_05_27_Time_0_ms_(100.00%)_Space_41.50_MB_(10.07%)
 
 public class Solution {
     public long minCuttingCost(int n, int m, int k) {

src/main/java/g3501_3600/s3561_resulting_string_after_adjacent_removals/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3561_resulting_string_after_adjacent_removals;
 
-// #Medium #2025_05_25_Time_36_ms_(100.00%)_Space_46.14_MB_(64.60%)
+// #Medium #String #Stack #Simulation #2025_05_27_Time_36_ms_(100.00%)_Space_46.01_MB_(75.40%)
 
 public class Solution {
     public String resultingString(String s) {

src/main/java/g3501_3600/s3562_maximum_profit_from_trading_stocks_with_discounts/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3562_maximum_profit_from_trading_stocks_with_discounts;
 
-// #Hard #2025_05_25_Time_27_ms_(100.00%)_Space_44.97_MB_(95.42%)
+// #Hard #Array #Dynamic_Programming #Tree #Depth_First_Search
+// #2025_05_27_Time_27_ms_(100.00%)_Space_45.29_MB_(82.12%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3501_3600/s3563_lexicographically_smallest_string_after_adjacent_removals/Solution.java

@@ -1,9 +1,8 @@
 package g3501_3600.s3563_lexicographically_smallest_string_after_adjacent_removals;
 
-// #Hard #2025_05_25_Time_146_ms_(98.77%)_Space_45.52_MB_(90.12%)
+// #Hard #String #Dynamic_Programming #2025_05_27_Time_121_ms_(99.09%)_Space_45.25_MB_(100.00%)
 
 public class Solution {
-
     private boolean checkPair(char char1, char char2) {
         int diffVal = Math.abs(char1 - char2);
         return diffVal == 1 || (char1 == 'a' && char2 == 'z') || (char1 == 'z' && char2 == 'a');