Improved tags

Author: javadev

src/main/java/g3201_3300/s3270_find_the_key_of_the_numbers/Solution.java

@@ -1,6 +1,6 @@
 package g3201_3300.s3270_find_the_key_of_the_numbers;
 
-// #Easy #2024_09_02_Time_0_ms_(100.00%)_Space_40.5_MB_(100.00%)
+// #Easy #Math #2024_09_02_Time_0_ms_(100.00%)_Space_40.5_MB_(100.00%)
 
 public class Solution {
     public int generateKey(int num1, int num2, int num3) {

src/main/java/g3201_3300/s3271_hash_divided_string/Solution.java

@@ -1,6 +1,6 @@
 package g3201_3300.s3271_hash_divided_string;
 
-// #Medium #2024_09_02_Time_2_ms_(100.00%)_Space_44.7_MB_(100.00%)
+// #Medium #String #Simulation #2024_09_02_Time_2_ms_(100.00%)_Space_44.7_MB_(100.00%)
 
 public class Solution {
     public String stringHash(String s, int k) {

src/main/java/g3201_3300/s3272_find_the_count_of_good_integers/Solution.java

@@ -1,6 +1,7 @@
 package g3201_3300.s3272_find_the_count_of_good_integers;
 
-// #Hard #2024_09_02_Time_167_ms_(100.00%)_Space_54.5_MB_(100.00%)
+// #Hard #Hash_Table #Math #Enumeration #Combinatorics
+// #2024_09_02_Time_167_ms_(100.00%)_Space_54.5_MB_(100.00%)
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -11,7 +12,7 @@
 import java.util.Set;
 
 public class Solution {
-    private List<String> palindromes = new ArrayList<>();
+    private final List<String> palindromes = new ArrayList<>();
 
     private long factorial(int n) {
         long res = 1;
@@ -71,9 +72,7 @@ private void generatePalindromes(
 
     private List<String> allKPalindromes(int n, int k) {
         StringBuilder ans = new StringBuilder(n);
-        for (int i = 0; i < n; i++) {
-            ans.append('0');
-        }
+        ans.append("0".repeat(Math.max(0, n)));
         int[] rem = new int[n];
         rem[0] = 1;
         for (int i = 1; i < n; i++) {

src/main/java/g3201_3300/s3273_minimum_amount_of_damage_dealt_to_bob/Solution.java

@@ -1,49 +1,56 @@
 package g3201_3300.s3273_minimum_amount_of_damage_dealt_to_bob;
 
-// #Hard #2024_09_02_Time_221_ms_(100.00%)_Space_59.9_MB_(100.00%)
+// #Hard #Array #Sorting #Greedy #2024_09_04_Time_76_ms_(100.00%)_Space_59.5_MB_(61.02%)
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.Arrays;
 
-@SuppressWarnings("java:S1210")
 public class Solution {
-    int total;
-    int power;
+    public long minDamage(int pw, int[] damage, int[] health) {
+        long res = 0;
+        long sum = 0;
+        for (int e : damage) {
+            sum += e;
+        }
+        Pair[] pairs = new Pair[damage.length];
+        for (int e = 0; e < damage.length; e++) {
+            pairs[e] = new Pair(damage[e], (health[e] + pw - 1) / pw);
+        }
+        Arrays.sort(pairs);
+        for (Pair pr : pairs) {
+            res += pr.val * sum;
+            sum -= pr.key;
+        }
+        return res;
+    }
 
-    private class Pair implements Comparable<Pair> {
-        int health;
-        int damage;
+    private static class Pair implements Comparable<Pair> {
+        public int key;
+        public int val;
 
-        Pair(int health, int damage) {
-            this.health = health;
-            this.damage = damage;
+        Pair(int key, int val) {
+            this.key = key;
+            this.val = val;
         }
 
         @Override
-        public int compareTo(Pair p) {
-            int thisHits = (int) Math.ceil((double) this.health / power);
-            int otherHits = (int) Math.ceil((double) p.health / power);
-            double thisTotalDamage = this.damage * 1.0 / thisHits;
-            double otherTotalDamage = p.damage * 1.0 / otherHits;
-            return Double.compare(otherTotalDamage, thisTotalDamage);
+        public boolean equals(Object o) {
+            Pair p1 = (Pair) o;
+            return key == p1.key && val == p1.val;
         }
-    }
 
-    public long minDamage(int power, int[] damage, int[] health) {
-        this.power = power;
-        total = 0;
-        List<Pair> pairs = new ArrayList<>();
-        for (int i = 0; i < damage.length; i++) {
-            pairs.add(new Pair(health[i], damage[i]));
-        }
-        Collections.sort(pairs);
-        long totalDamage = 0;
-        int hitsRequired = 0;
-        for (Pair pair : pairs) {
-            hitsRequired += (int) Math.ceil((double) pair.health / power);
-            totalDamage += (long) hitsRequired * pair.damage;
-        }
-        return totalDamage;
+        @Override
+        public int hashCode() {
+            return key ^ val;
+        }
+
+        @Override
+        public String toString() {
+            return "[" + key + " - " + val + "]";
+        }
+
+        @Override
+        public int compareTo(Pair p) {
+            return val * p.key - key * p.val;
+        }
     }
 }

src/main/java/g3201_3300/s3274_check_if_two_chessboard_squares_have_the_same_color/Solution.java

@@ -1,6 +1,6 @@
 package g3201_3300.s3274_check_if_two_chessboard_squares_have_the_same_color;
 
-// #Easy #2024_09_02_Time_0_ms_(100.00%)_Space_41.8_MB_(100.00%)
+// #Easy #String #Math #2024_09_02_Time_0_ms_(100.00%)_Space_41.8_MB_(100.00%)
 
 public class Solution {
     public boolean checkTwoChessboards(String c1, String c2) {

src/main/java/g3201_3300/s3275_k_th_nearest_obstacle_queries/Solution.java

@@ -1,29 +1,51 @@
 package g3201_3300.s3275_k_th_nearest_obstacle_queries;
 
-// #Medium #2024_09_02_Time_126_ms_(100.00%)_Space_129.6_MB_(100.00%)
-
-import java.util.Arrays;
-import java.util.PriorityQueue;
+// #Medium #Array #Heap_Priority_Queue #2024_09_04_Time_33_ms_(100.00%)_Space_162_MB_(37.19%)
 
 public class Solution {
     public int[] resultsArray(int[][] queries, int k) {
-        int[] output = new int[queries.length];
-        Arrays.fill(output, -1);
-        PriorityQueue<int[]> heap =
-                new PriorityQueue<>(
-                        (a, b) ->
-                                (Math.abs(b[0]) + Math.abs(b[1]))
-                                        - (Math.abs(a[0]) + Math.abs(a[1])));
-        for (int i = 0; i < output.length; ++i) {
-            heap.offer(queries[i]);
-            if (heap.size() > k) {
-                heap.poll();
-            }
-            if (heap.size() == k) {
-                int[] currkth = heap.peek();
-                output[i] = Math.abs(currkth[0]) + Math.abs(currkth[1]);
+        final int len = queries.length;
+        int[] results = new int[len];
+        int[] heap = new int[k];
+        for (int i = 0; i < k && i < len; i++) {
+            int[] query = queries[i];
+            heap[i] = Math.abs(query[0]) + Math.abs(query[1]);
+            results[i] = -1;
+        }
+        if (k <= len) {
+            buildMaxHeap(heap, k);
+            results[k - 1] = heap[0];
+        }
+        for (int i = k; i < len; i++) {
+            int[] query = queries[i];
+            int dist = Math.abs(query[0]) + Math.abs(query[1]);
+            if (dist < heap[0]) {
+                heap[0] = dist;
+                heapify(heap, 0, k);
             }
+            results[i] = heap[0];
+        }
+        return results;
+    }
+
+    private void buildMaxHeap(int[] heap, int size) {
+        for (int i = size / 2 - 1; i >= 0; i--) {
+            heapify(heap, i, size);
+        }
+    }
+
+    private void heapify(int[] heap, int index, int size) {
+        int root = heap[index];
+        final int left = 2 * index + 1;
+        final int right = 2 * index + 2;
+        if (right < size && root < heap[right] && heap[left] < heap[right]) {
+            heap[index] = heap[right];
+            heap[right] = root;
+            heapify(heap, right, size);
+        } else if (left < size && root < heap[left]) {
+            heap[index] = heap[left];
+            heap[left] = root;
+            heapify(heap, left, size);
         }
-        return output;
     }
 }

src/main/java/g3201_3300/s3276_select_cells_in_grid_with_maximum_score/Solution.java

@@ -1,50 +1,44 @@
 package g3201_3300.s3276_select_cells_in_grid_with_maximum_score;
 
-// #Hard #2024_09_02_Time_36_ms_(100.00%)_Space_48.5_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Matrix #Bit_Manipulation #Bitmask
+// #2024_09_04_Time_6_ms_(99.82%)_Space_44.1_MB_(91.67%)
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 public class Solution {
     public int maxScore(List<List<Integer>> grid) {
         int n = grid.size();
         int m = grid.get(0).size();
-        List<List<Integer>> list = new ArrayList<>();
-        for (int i = 0; i <= 100; i++) {
-            list.add(new ArrayList<>());
-        }
-        int max = 0;
+        int[][] arr = new int[n * m][2];
         for (int i = 0; i < n; i++) {
-            for (int j = 0; j < m; j++) {
-                int num = grid.get(i).get(j);
-                list.get(num).add(i);
-                max = Math.max(grid.get(i).get(j), max);
+            List<Integer> l = grid.get(i);
+            for (int j = 0; j < l.size(); j++) {
+                arr[i * m + j][0] = l.get(j);
+                arr[i * m + j][1] = i;
             }
         }
-        int[][] dp = new int[max + 1][(1 << n) * 2 - 1];
-        for (int[] arr : dp) {
-            Arrays.fill(arr, -1);
-        }
-        return helper(max, 0, list, dp);
-    }
-
-    private int helper(int n, int mask, List<List<Integer>> list, int[][] dp) {
-        if (n == 0) {
-            return 0;
-        }
-        if (dp[n][mask] != -1) {
-            return dp[n][mask];
-        }
-        int take = Integer.MIN_VALUE;
-        for (int row : list.get(n)) {
-            if ((mask & (1 << row)) != 0) {
-                continue;
+        Arrays.sort(arr, (a, b) -> b[0] - a[0]);
+        int[] dp = new int[1 << n];
+        for (int i = 0; i < arr.length; ) {
+            boolean[] seen = new boolean[n];
+            seen[arr[i][1]] = true;
+            int v = arr[i][0];
+            for (i++; i < arr.length && arr[i][0] == v; i++) {
+                seen[arr[i][1]] = true;
+            }
+            int[] next = Arrays.copyOf(dp, dp.length);
+            for (int j = 0; j < n; j++) {
+                if (seen[j]) {
+                    int and = ((1 << n) - 1) ^ (1 << j);
+                    for (int k = and; k > 0; k = (k - 1) & and) {
+                        next[k | (1 << j)] = Math.max(next[k | (1 << j)], dp[k] + v);
+                    }
+                    next[1 << j] = Math.max(next[1 << j], v);
+                }
             }
-            take = Math.max(n + helper(n - 1, mask | (1 << row), list, dp), take);
+            dp = next;
         }
-        int notTake = helper(n - 1, mask, list, dp);
-        dp[n][mask] = Math.max(take, notTake);
-        return dp[n][mask];
+        return dp[dp.length - 1];
     }
 }

src/main/java/g3201_3300/s3277_maximum_xor_score_subarray_queries/Solution.java

@@ -1,30 +1,29 @@
 package g3201_3300.s3277_maximum_xor_score_subarray_queries;
 
-// #Hard #2024_09_02_Time_62_ms_(100.00%)_Space_90.5_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #2024_09_04_Time_29_ms_(98.87%)_Space_104.3_MB_(65.54%)
 
-@SuppressWarnings("java:S3012")
 public class Solution {
     public int[] maximumSubarrayXor(int[] nums, int[][] queries) {
         int n = nums.length;
-        int[][] t = new int[n][n];
-        for (int j = 0; j < n; j++) {
-            t[j][j] = nums[j];
+        int[][] dp = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = nums[i];
         }
-        for (int j = 1; j < n; j++) {
-            for (int i = 0; i + j < n; i++) {
-                t[i][i + j] = t[i][i + j - 1] ^ t[i + 1][i + j];
+        for (int i = n - 2; i >= 0; i--) {
+            for (int j = i + 1; j < n; j++) {
+                dp[i][j] = dp[i][j - 1] ^ dp[i + 1][j];
             }
         }
-        for (int j = 1; j < n; j++) {
-            for (int i = 0; i + j < n; i++) {
-                t[i][i + j] = Math.max(t[i][i + j], Math.max(t[i][i + j - 1], t[i + 1][i + j]));
+        for (int i = n - 2; i >= 0; i--) {
+            for (int j = i + 1; j < n; j++) {
+                dp[i][j] = Math.max(dp[i][j], Math.max(dp[i][j - 1], dp[i + 1][j]));
             }
         }
-        int[] ans = new int[queries.length];
-        for (int i = 0; i < queries.length; i++) {
-            int l = queries[i][0];
-            int r = queries[i][1];
-            ans[i] = t[l][r];
+        int q = queries.length;
+        int[] ans = new int[q];
+        int time = 0;
+        for (int[] query : queries) {
+            ans[time++] = dp[query[0]][query[1]];
         }
         return ans;
     }