Improved tasks 93, 990, 1131, 2056, 2241

src/main/java/g0001_0100/s0093_restore_ip_addresses/Solution.java

@@ -1,41 +1,53 @@
 package g0001_0100.s0093_restore_ip_addresses;
 
-// #Medium #String #Backtracking #2022_06_21_Time_13_ms_(24.23%)_Space_42.8_MB_(71.26%)
+// #Medium #String #Backtracking #2024_05_13_Time_1_ms_(99.27%)_Space_42_MB_(90.75%)
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class Solution {
+    private static final int SEG_COUNT = 4;
+    private List<String> result = new ArrayList<>();
+    private int[] segments = new int[SEG_COUNT];
+
     public List<String> restoreIpAddresses(String s) {
-        List<String> results = new ArrayList<>();
-        step(s, 0, new int[4], 0, results);
-        return results;
+        dfs(s, 0, 0);
+        return result;
     }
 
-    void step(String s, int pos, int[] octets, int count, List<String> results) {
-        if (count == 4 && pos == s.length()) {
-            results.add(
-                    String.valueOf(octets[0])
-                            + '.'
-                            + octets[1]
-                            + '.'
-                            + octets[2]
-                            + '.'
-                            + octets[3]);
-        } else if (count < 4 && pos < 12) {
-            int octet = 0;
-            for (int i = 0; i < 3; i++) {
-                if (pos + i < s.length()) {
-                    int digit = s.charAt(pos + i) - '0';
-                    octet = octet * 10 + digit;
-                    if (octet < 256) {
-                        octets[count] = octet;
-                        step(s, pos + i + 1, octets, count + 1, results);
-                    }
-                    if (i == 0 && digit == 0) {
-                        break;
+    public void dfs(String s, int segId, int segStart) {
+        // find 4 segments and get to last index
+        if (segId == SEG_COUNT) {
+            if (segStart == s.length()) {
+                StringBuilder addr = new StringBuilder();
+                for (int i = 0; i < SEG_COUNT; i++) {
+                    addr.append(segments[i]);
+                    if (i != SEG_COUNT - 1) {
+                        addr.append('.');
                     }
                 }
+                result.add(addr.toString());
+            }
+            return;
+        }
+        // last index and no 4 segments
+        if (segStart == s.length()) {
+            return;
+        }
+        // start with a zero
+        if (s.charAt(segStart) == '0') {
+            segments[segId] = 0;
+            dfs(s, segId + 1, segStart + 1);
+            return;
+        }
+        int addr = 0;
+        for (int index = segStart; index < s.length(); index++) {
+            addr = addr * 10 + s.charAt(index) - '0';
+            if (addr >= 0 && addr <= 255) {
+                segments[segId] = addr;
+                dfs(s, segId + 1, index + 1);
+            } else {
+                break;
             }
         }
     }

src/main/java/g0901_1000/s0990_satisfiability_of_equality_equations/Solution.java

@@ -1,59 +1,32 @@
 package g0901_1000.s0990_satisfiability_of_equality_equations;
 
-// #Medium #Array #String #Graph #Union_Find #2022_03_31_Time_5_ms_(24.79%)_Space_43.5_MB_(18.67%)
-
-import java.util.HashMap;
+// #Medium #Array #String #Graph #Union_Find #2024_05_13_Time_0_ms_(100.00%)_Space_41.9_MB_(47.21%)
 
 public class Solution {
-    private int[] par;
+    private int[] parent = new int[26];
 
-    public boolean equationsPossible(String[] equations) {
-        int counter = 0;
-        HashMap<Character, Integer> map = new HashMap<>();
-        for (String str : equations) {
-            char ch = str.charAt(0);
-            if (!map.containsKey(ch)) {
-                map.put(ch, counter);
-                counter++;
-            }
-            ch = str.charAt(3);
-            if (!map.containsKey(ch)) {
-                map.put(ch, counter);
-                counter++;
-            }
+    private int find(int x) {
+        if (parent[x] == x) {
+            return x;
         }
-        par = new int[counter];
-        for (int i = 0; i < par.length; i++) {
-            par[i] = i;
+        parent[x] = find(parent[x]);
+        return parent[x];
+    }
+
+    public boolean equationsPossible(String[] equations) {
+        for (int i = 0; i < 26; i++) {
+            parent[i] = i;
         }
-        for (String str : equations) {
-            String oper = str.substring(1, 3);
-            if (oper.equals("==")) {
-                int px = find(map.get(str.charAt(0)));
-                int py = find(map.get(str.charAt(3)));
-                if (px != py) {
-                    par[px] = py;
-                }
+        for (String e : equations) {
+            if (e.charAt(1) == '=') {
+                parent[find(e.charAt(0) - 'a')] = find(e.charAt(3) - 'a');
             }
         }
-        for (String str : equations) {
-            String oper = str.substring(1, 3);
-            if (oper.equals("!=")) {
-                int px = find(map.get(str.charAt(0)));
-                int py = find(map.get(str.charAt(3)));
-                if (px == py) {
-                    return false;
-                }
+        for (String e : equations) {
+            if (e.charAt(1) == '!' && find(e.charAt(0) - 'a') == find(e.charAt(3) - 'a')) {
+                return false;
             }
         }
         return true;
     }
-
-    private int find(int x) {
-        if (par[x] == x) {
-            return x;
-        }
-        par[x] = find(par[x]);
-        return par[x];
-    }
 }

src/main/java/g1101_1200/s1131_maximum_of_absolute_value_expression/Solution.java

@@ -1,30 +1,31 @@
 package g1101_1200.s1131_maximum_of_absolute_value_expression;
 
-// #Medium #Array #Math #2023_06_01_Time_13_ms_(24.81%)_Space_52.7_MB_(5.43%)
+// #Medium #Array #Math #2024_05_13_Time_1_ms_(100.00%)_Space_53_MB_(70.47%)
 
 public class Solution {
-    public int maxAbsValExpr(int[] arr1, int[] arr2) {
-        if (arr1.length != arr2.length) {
+    private int max(int[] a1, int[] a2, int k1, int k2, int k3) {
+        int result = Integer.MIN_VALUE;
+        for (int i = 0; i < a1.length; i++) {
+            result = Math.max(result, a1[i] * k1 + a2[i] * k2 + i * k3);
+        }
+        return result;
+    }
+
+    private int min(int[] a1, int[] a2, int k1, int k2, int k3) {
+        return -max(a1, a2, -k1, -k2, -k3);
+    }
+
+    public int maxAbsValExpr(int[] a1, int[] a2) {
+        if (a1 == null || a2 == null || a1.length == 0 || a2.length == 0) {
             return 0;
         }
-        int max1 = Integer.MIN_VALUE;
-        int max2 = Integer.MIN_VALUE;
-        int max3 = Integer.MIN_VALUE;
-        int max4 = Integer.MIN_VALUE;
-        int min1 = Integer.MAX_VALUE;
-        int min2 = Integer.MAX_VALUE;
-        int min3 = Integer.MAX_VALUE;
-        int min4 = Integer.MAX_VALUE;
-        for (int i = 0; i < arr1.length; i++) {
-            max1 = Math.max(arr1[i] + arr2[i] + i, max1);
-            min1 = Math.min(arr1[i] + arr2[i] + i, min1);
-            max2 = Math.max(i - arr1[i] - arr2[i], max2);
-            min2 = Math.min(i - arr1[i] - arr2[i], min2);
-            max3 = Math.max(arr1[i] - arr2[i] + i, max3);
-            min3 = Math.min(arr1[i] - arr2[i] + i, min3);
-            max4 = Math.max(arr2[i] - arr1[i] + i, max4);
-            min4 = Math.min(arr2[i] - arr1[i] + i, min4);
+        int result = 0;
+        int[][] ksArray = {{1, 1, 1}, {1, 1, -1}, {1, -1, 1}, {1, -1, -1}};
+        for (int[] ks : ksArray) {
+            int max = max(a1, a2, ks[0], ks[1], ks[2]);
+            int min = min(a1, a2, ks[0], ks[1], ks[2]);
+            result = Math.max(result, max - min);
         }
-        return Math.max(Math.max(max1 - min1, max2 - min2), Math.max(max3 - min3, max4 - min4));
+        return result;
     }
 }

src/main/java/g2001_2100/s2056_number_of_valid_move_combinations_on_chessboard/Solution.java

@@ -1,7 +1,7 @@
 package g2001_2100.s2056_number_of_valid_move_combinations_on_chessboard;
 
 // #Hard #Array #String #Simulation #Backtracking
-// #2022_05_30_Time_433_ms_(24.83%)_Space_144.4_MB_(12.75%)
+// #2024_05_13_Time_195_ms_(41.18%)_Space_44.8_MB_(47.06%)
 
 import java.util.ArrayList;
 import java.util.HashSet;

src/main/java/g2201_2300/s2241_design_an_atm_machine/ATM.java

@@ -1,6 +1,6 @@
 package g2201_2300.s2241_design_an_atm_machine;
 
-// #Medium #Array #Greedy #Design #2022_06_08_Time_192_ms_(24.16%)_Space_120.4_MB_(5.07%)
+// #Medium #Array #Greedy #Design #2024_05_13_Time_55_ms_(94.44%)_Space_48.6_MB_(19.59%)
 
 public class ATM {
     private int[] nominals;