Added tasks 3492-3495

Author: javadev

src/main/java/g3401_3500/s3492_maximum_containers_on_a_ship/Solution.java

@@ -0,0 +1,11 @@
+package g3401_3500.s3492_maximum_containers_on_a_ship;
+
+// #Easy #2025_03_23_Time_0_ms_(100.00%)_Space_40.80_MB_(88.06%)
+
+public class Solution {
+    public int maxContainers(int n, int w, int maxWeight) {
+        int c = n * n;
+        int count = maxWeight / w;
+        return Math.min(c, count);
+    }
+}

src/main/java/g3401_3500/s3492_maximum_containers_on_a_ship/readme.md

@@ -0,0 +1,35 @@
+3492\. Maximum Containers on a Ship
+
+Easy
+
+You are given a positive integer `n` representing an `n x n` cargo deck on a ship. Each cell on the deck can hold one container with a weight of **exactly** `w`.
+
+However, the total weight of all containers, if loaded onto the deck, must not exceed the ship's maximum weight capacity, `maxWeight`.
+
+Return the **maximum** number of containers that can be loaded onto the ship.
+
+**Example 1:**
+
+**Input:** n = 2, w = 3, maxWeight = 15
+
+**Output:** 4
+
+**Explanation:**
+
+The deck has 4 cells, and each container weighs 3. The total weight of loading all containers is 12, which does not exceed `maxWeight`.
+
+**Example 2:**
+
+**Input:** n = 3, w = 5, maxWeight = 20
+
+**Output:** 4
+
+**Explanation:**
+
+The deck has 9 cells, and each container weighs 5. The maximum number of containers that can be loaded without exceeding `maxWeight` is 4.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`
+*   `1 <= w <= 1000`
+*   <code>1 <= maxWeight <= 10<sup>9</sup></code>

src/main/java/g3401_3500/s3493_properties_graph/Solution.java

@@ -0,0 +1,72 @@
+package g3401_3500.s3493_properties_graph;
+
+// #Medium #2025_03_23_Time_28_ms_(99.84%)_Space_46.29_MB_(19.15%)
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+    private int[] parent;
+
+    public int numberOfComponents(int[][] properties, int k) {
+        List<List<Integer>> al = convertToList(properties);
+        int n = al.size();
+        List<BitSet> bs = new ArrayList<>(n);
+        for (List<Integer> integers : al) {
+            BitSet bitset = new BitSet(101);
+            for (int num : integers) {
+                bitset.set(num);
+            }
+            bs.add(bitset);
+        }
+        parent = new int[n];
+        for (int i = 0; i < n; i++) {
+            parent[i] = i;
+        }
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                BitSet temp = (BitSet) bs.get(i).clone();
+                temp.and(bs.get(j));
+                int common = temp.cardinality();
+                if (common >= k) {
+                    unionn(i, j);
+                }
+            }
+        }
+        Set<Integer> comps = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            comps.add(findp(i));
+        }
+        return comps.size();
+    }
+
+    private int findp(int x) {
+        if (parent[x] != x) {
+            parent[x] = findp(parent[x]); // Path compression
+        }
+        return parent[x];
+    }
+
+    private void unionn(int a, int b) {
+        int pa = findp(a);
+        int pb = findp(b);
+        if (pa != pb) {
+            parent[pa] = pb;
+        }
+    }
+
+    private List<List<Integer>> convertToList(int[][] arr) {
+        List<List<Integer>> list = new ArrayList<>();
+        for (int[] row : arr) {
+            List<Integer> temp = new ArrayList<>();
+            for (int num : row) {
+                temp.add(num);
+            }
+            list.add(temp);
+        }
+        return list;
+    }
+}

src/main/java/g3401_3500/s3493_properties_graph/readme.md

@@ -0,0 +1,52 @@
+3493\. Properties Graph
+
+Medium
+
+You are given a 2D integer array `properties` having dimensions `n x m` and an integer `k`.
+
+Define a function `intersect(a, b)` that returns the **number of distinct integers** common to both arrays `a` and `b`.
+
+Construct an **undirected** graph where each index `i` corresponds to `properties[i]`. There is an edge between node `i` and node `j` if and only if `intersect(properties[i], properties[j]) >= k`, where `i` and `j` are in the range `[0, n - 1]` and `i != j`.
+
+Return the number of **connected components** in the resulting graph.
+
+**Example 1:**
+
+**Input:** properties = [[1,2],[1,1],[3,4],[4,5],[5,6],[7,7]], k = 1
+
+**Output:** 3
+
+**Explanation:**
+
+The graph formed has 3 connected components:
+
+![](https://assets.leetcode.com/uploads/2025/02/27/image.png)
+
+**Example 2:**
+
+**Input:** properties = [[1,2,3],[2,3,4],[4,3,5]], k = 2
+
+**Output:** 1
+
+**Explanation:**
+
+The graph formed has 1 connected component:
+
+![](https://assets.leetcode.com/uploads/2025/02/27/screenshot-from-2025-02-27-23-58-34.png)
+
+**Example 3:**
+
+**Input:** properties = [[1,1],[1,1]], k = 2
+
+**Output:** 2
+
+**Explanation:**
+
+`intersect(properties[0], properties[1]) = 1`, which is less than `k`. This means there is no edge between `properties[0]` and `properties[1]` in the graph.
+
+**Constraints:**
+
+*   `1 <= n == properties.length <= 100`
+*   `1 <= m == properties[i].length <= 100`
+*   `1 <= properties[i][j] <= 100`
+*   `1 <= k <= m`

src/main/java/g3401_3500/s3494_find_the_minimum_amount_of_time_to_brew_potions/Solution.java

@@ -0,0 +1,25 @@
+package g3401_3500.s3494_find_the_minimum_amount_of_time_to_brew_potions;
+
+// #Medium #2025_03_23_Time_115_ms_(91.61%)_Space_44.66_MB_(83.22%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long minTime(int[] skill, int[] mana) {
+        long[] endTime = new long[skill.length];
+        Arrays.fill(endTime, 0);
+        for (int k : mana) {
+            long t = 0;
+            long maxDiff = 0;
+            for (int j = 0; j < skill.length; ++j) {
+                maxDiff = Math.max(maxDiff, endTime[j] - t);
+                t += (long) skill[j] * (long) k;
+                endTime[j] = t;
+            }
+            for (int j = 0; j < skill.length; ++j) {
+                endTime[j] += maxDiff;
+            }
+        }
+        return endTime[endTime.length - 1];
+    }
+}

src/main/java/g3401_3500/s3494_find_the_minimum_amount_of_time_to_brew_potions/readme.md

@@ -0,0 +1,106 @@
+3494\. Find the Minimum Amount of Time to Brew Potions
+
+Medium
+
+You are given two integer arrays, `skill` and `mana`, of length `n` and `m`, respectively.
+
+In a laboratory, `n` wizards must brew `m` potions _in order_. Each potion has a mana capacity `mana[j]` and **must** pass through **all** the wizards sequentially to be brewed properly. The time taken by the <code>i<sup>th</sup></code> wizard on the <code>j<sup>th</sup></code> potion is <code>time<sub>ij</sub> = skill[i] * mana[j]</code>.
+
+Since the brewing process is delicate, a potion **must** be passed to the next wizard immediately after the current wizard completes their work. This means the timing must be _synchronized_ so that each wizard begins working on a potion **exactly** when it arrives.
+
+Return the **minimum** amount of time required for the potions to be brewed properly.
+
+**Example 1:**
+
+**Input:** skill = [1,5,2,4], mana = [5,1,4,2]
+
+**Output:** 110
+
+**Explanation:**
+
+Potion Number
+
+Start time
+
+Wizard 0 done by
+
+Wizard 1 done by
+
+Wizard 2 done by
+
+Wizard 3 done by
+
+0
+
+0
+
+5
+
+30
+
+40
+
+60
+
+1
+
+52
+
+53
+
+58
+
+60
+
+64
+
+2
+
+54
+
+58
+
+78
+
+86
+
+102
+
+3
+
+86
+
+88
+
+98
+
+102
+
+110
+
+As an example for why wizard 0 cannot start working on the 1<sup>st</sup> potion before time `t = 52`, consider the case where the wizards started preparing the 1<sup>st</sup> potion at time `t = 50`. At time `t = 58`, wizard 2 is done with the 1<sup>st</sup> potion, but wizard 3 will still be working on the 0<sup>th</sup> potion till time `t = 60`.
+
+**Example 2:**
+
+**Input:** skill = [1,1,1], mana = [1,1,1]
+
+**Output:** 5
+
+**Explanation:**
+
+1.  Preparation of the 0<sup>th</sup> potion begins at time `t = 0`, and is completed by time `t = 3`.
+2.  Preparation of the 1<sup>st</sup> potion begins at time `t = 1`, and is completed by time `t = 4`.
+3.  Preparation of the 2<sup>nd</sup> potion begins at time `t = 2`, and is completed by time `t = 5`.
+
+**Example 3:**
+
+**Input:** skill = [1,2,3,4], mana = [1,2]
+
+**Output:** 21
+
+**Constraints:**
+
+*   `n == skill.length`
+*   `m == mana.length`
+*   `1 <= n, m <= 5000`
+*   `1 <= mana[i], skill[i] <= 5000`

src/main/java/g3401_3500/s3495_minimum_operations_to_make_array_elements_zero/Solution.java

@@ -0,0 +1,42 @@
+package g3401_3500.s3495_minimum_operations_to_make_array_elements_zero;
+
+// #Hard #2025_03_23_Time_9_ms_(100.00%)_Space_101.25_MB_(65.40%)
+
+public class Solution {
+    public long minOperations(int[][] queries) {
+        long result = 0;
+        for (int[] query : queries) {
+            long v = 4;
+            long req = 1;
+            long totalReq = 0;
+            while (query[0] >= v) {
+                v *= 4;
+                req++;
+            }
+            long group;
+            if (query[1] < v) {
+                group = query[1] - query[0] + 1;
+                totalReq += group * req;
+                result += (totalReq + 1) / 2;
+                continue;
+            }
+            group = v - query[0];
+            totalReq += group * req;
+            long bottom = v;
+            while (true) {
+                v *= 4;
+                req++;
+                if (query[1] < v) {
+                    group = query[1] - bottom + 1;
+                    totalReq += group * req;
+                    break;
+                }
+                group = v - bottom;
+                totalReq += group * req;
+                bottom = v;
+            }
+            result += (totalReq + 1) / 2;
+        }
+        return result;
+    }
+}