Added tasks 3507-3510

Author: javadev

src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/Solution.java

@@ -0,0 +1,48 @@
+package g3501_3600.s3507_minimum_pair_removal_to_sort_array_i;
+
+// #Easy #Array #Hash_Table #Heap_Priority_Queue #Simulation #Linked_List #Ordered_Set
+// #Doubly_Linked_List #2025_04_09_Time_1_ms_(100.00%)_Space_42.96_MB_(53.67%)
+
+public class Solution {
+    public int minimumPairRemoval(int[] nums) {
+        int operations = 0;
+        while (!isNonDecreasing(nums)) {
+            int minSum = Integer.MAX_VALUE;
+            int index = 0;
+            // Find the leftmost pair with minimum sum
+            for (int i = 0; i < nums.length - 1; i++) {
+                int sum = nums[i] + nums[i + 1];
+                if (sum < minSum) {
+                    minSum = sum;
+                    index = i;
+                }
+            }
+            // Merge the pair at index
+            int[] newNums = new int[nums.length - 1];
+            int j = 0;
+            int i = 0;
+            while (i < nums.length) {
+                if (i == index) {
+                    newNums[j++] = nums[i] + nums[i + 1];
+                    // Skip the next one since it's merged
+                    i++;
+                } else {
+                    newNums[j++] = nums[i];
+                }
+                i++;
+            }
+            nums = newNums;
+            operations++;
+        }
+        return operations;
+    }
+
+    private boolean isNonDecreasing(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < nums[i - 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/readme.md

@@ -0,0 +1,40 @@
+3507\. Minimum Pair Removal to Sort Array I
+
+Easy
+
+Given an array `nums`, you can perform the following operation any number of times:
+
+*   Select the **adjacent** pair with the **minimum** sum in `nums`. If multiple such pairs exist, choose the leftmost one.
+*   Replace the pair with their sum.
+
+Return the **minimum number of operations** needed to make the array **non-decreasing**.
+
+An array is said to be **non-decreasing** if each element is greater than or equal to its previous element (if it exists).
+
+**Example 1:**
+
+**Input:** nums = [5,2,3,1]
+
+**Output:** 2
+
+**Explanation:**
+
+*   The pair `(3,1)` has the minimum sum of 4. After replacement, `nums = [5,2,4]`.
+*   The pair `(2,4)` has the minimum sum of 6. After replacement, `nums = [5,6]`.
+
+The array `nums` became non-decreasing in two operations.
+
+**Example 2:**
+
+**Input:** nums = [1,2,2]
+
+**Output:** 0
+
+**Explanation:**
+
+The array `nums` is already sorted.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 50`
+*   `-1000 <= nums[i] <= 1000`

src/main/java/g3501_3600/s3508_implement_router/Router.java

@@ -0,0 +1,107 @@
+package g3501_3600.s3508_implement_router;
+
+// #Medium #Array #Hash_Table #Binary_Search #Design #Ordered_Set #Queue
+// #2025_04_09_Time_137_ms_(100.00%)_Space_116.63_MB_(91.98%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Queue;
+
+@SuppressWarnings("java:S135")
+public class Router {
+    private final int size;
+    private int cur;
+    private final Queue<int[]> q;
+    private final HashMap<Integer, ArrayList<int[]>> map;
+
+    public Router(int memoryLimit) {
+        q = new LinkedList<>();
+        map = new HashMap<>();
+        size = memoryLimit;
+        cur = 0;
+    }
+
+    public boolean addPacket(int source, int destination, int timestamp) {
+        if (map.containsKey(destination)) {
+            boolean found = false;
+            ArrayList<int[]> list = map.get(destination);
+            for (int i = list.size() - 1; i >= 0; i--) {
+                if (list.get(i)[1] < timestamp) {
+                    break;
+                } else if (list.get(i)[0] == source) {
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                return false;
+            }
+        }
+        if (map.containsKey(destination)) {
+            ArrayList<int[]> list = map.get(destination);
+            list.add(new int[] {source, timestamp});
+            cur++;
+            q.offer(new int[] {source, destination, timestamp});
+        } else {
+            ArrayList<int[]> temp = new ArrayList<>();
+            temp.add(new int[] {source, timestamp});
+            cur++;
+            map.put(destination, temp);
+            q.offer(new int[] {source, destination, timestamp});
+        }
+        if (cur > size) {
+            forwardPacket();
+        }
+        return true;
+    }
+
+    public int[] forwardPacket() {
+        if (q.isEmpty()) {
+            return new int[] {};
+        }
+        int[] temp = q.poll();
+        ArrayList<int[]> list = map.get(temp[1]);
+        list.remove(0);
+        if (list.isEmpty()) {
+            map.remove(temp[1]);
+        }
+        cur--;
+        return temp;
+    }
+
+    public int getCount(int destination, int startTime, int endTime) {
+        if (map.containsKey(destination)) {
+            ArrayList<int[]> list = map.get(destination);
+            int lower = -1;
+            int higher = -1;
+            for (int i = 0; i < list.size(); i++) {
+                if (list.get(i)[1] >= startTime) {
+                    lower = i;
+                    break;
+                }
+            }
+            for (int i = list.size() - 1; i >= 0; i--) {
+                if (list.get(i)[1] <= endTime) {
+                    higher = i;
+                    break;
+                }
+            }
+            if (lower == -1 || higher == -1) {
+                return 0;
+            } else {
+                return Math.max(0, higher - lower + 1);
+            }
+        } else {
+            return 0;
+        }
+    }
+}
+
+/*
+ * Your Router object will be instantiated and called as such:
+ * Router obj = new Router(memoryLimit);
+ * boolean param_1 = obj.addPacket(source,destination,timestamp);
+ * int[] param_2 = obj.forwardPacket();
+ * int param_3 = obj.getCount(destination,startTime,endTime);
+ */

src/main/java/g3501_3600/s3508_implement_router/readme.md

@@ -0,0 +1,79 @@
+3508\. Implement Router
+
+Medium
+
+Design a data structure that can efficiently manage data packets in a network router. Each data packet consists of the following attributes:
+
+*   `source`: A unique identifier for the machine that generated the packet.
+*   `destination`: A unique identifier for the target machine.
+*   `timestamp`: The time at which the packet arrived at the router.
+
+Implement the `Router` class:
+
+`Router(int memoryLimit)`: Initializes the Router object with a fixed memory limit.
+
+*   `memoryLimit` is the **maximum** number of packets the router can store at any given time.
+*   If adding a new packet would exceed this limit, the **oldest** packet must be removed to free up space.
+
+`bool addPacket(int source, int destination, int timestamp)`: Adds a packet with the given attributes to the router.
+
+*   A packet is considered a duplicate if another packet with the same `source`, `destination`, and `timestamp` already exists in the router.
+*   Return `true` if the packet is successfully added (i.e., it is not a duplicate); otherwise return `false`.
+
+`int[] forwardPacket()`: Forwards the next packet in FIFO (First In First Out) order.
+
+*   Remove the packet from storage.
+*   Return the packet as an array `[source, destination, timestamp]`.
+*   If there are no packets to forward, return an empty array.
+
+`int getCount(int destination, int startTime, int endTime)`:
+
+*   Returns the number of packets currently stored in the router (i.e., not yet forwarded) that have the specified destination and have timestamps in the inclusive range `[startTime, endTime]`.
+
+**Note** that queries for `addPacket` will be made in increasing order of `timestamp`.
+
+**Example 1:**
+
+**Input:**   
+ ["Router", "addPacket", "addPacket", "addPacket", "addPacket", "addPacket", "forwardPacket", "addPacket", "getCount"]   
+ [[3], [1, 4, 90], [2, 5, 90], [1, 4, 90], [3, 5, 95], [4, 5, 105], [], [5, 2, 110], [5, 100, 110]]
+
+**Output:**   
+ [null, true, true, false, true, true, [2, 5, 90], true, 1]
+
+**Explanation**
+
+Router router = new Router(3); // Initialize Router with memoryLimit of 3.   
+ router.addPacket(1, 4, 90); // Packet is added. Return True.   
+ router.addPacket(2, 5, 90); // Packet is added. Return True.   
+ router.addPacket(1, 4, 90); // This is a duplicate packet. Return False.   
+ router.addPacket(3, 5, 95); // Packet is added. Return True   
+ router.addPacket(4, 5, 105); // Packet is added, `[1, 4, 90]` is removed as number of packets exceeds memoryLimit. Return True.   
+ router.forwardPacket(); // Return `[2, 5, 90]` and remove it from router.   
+ router.addPacket(5, 2, 110); // Packet is added. Return True.   
+ router.getCount(5, 100, 110); // The only packet with destination 5 and timestamp in the inclusive range `[100, 110]` is `[4, 5, 105]`. Return 1.
+
+**Example 2:**
+
+**Input:**   
+ ["Router", "addPacket", "forwardPacket", "forwardPacket"]   
+ [[2], [7, 4, 90], [], []]
+
+**Output:**   
+ [null, true, [7, 4, 90], []]
+
+**Explanation**
+
+Router router = new Router(2); // Initialize `Router` with `memoryLimit` of 2.   
+ router.addPacket(7, 4, 90); // Return True.   
+ router.forwardPacket(); // Return `[7, 4, 90]`.   
+ router.forwardPacket(); // There are no packets left, return `[]`.
+
+**Constraints:**
+
+*   <code>2 <= memoryLimit <= 10<sup>5</sup></code>
+*   <code>1 <= source, destination <= 2 * 10<sup>5</sup></code>
+*   <code>1 <= timestamp <= 10<sup>9</sup></code>
+*   <code>1 <= startTime <= endTime <= 10<sup>9</sup></code>
+*   At most <code>10<sup>5</sup></code> calls will be made to `addPacket`, `forwardPacket`, and `getCount` methods altogether.
+*   queries for `addPacket` will be made in increasing order of `timestamp`.