Added tasks 3648-3655

Author: javadev

src/main/java/g3601_3700/s3648_minimum_sensors_to_cover_grid/Solution.java

@@ -0,0 +1,12 @@
+package g3601_3700.s3648_minimum_sensors_to_cover_grid;
+
+// #Medium #Biweekly_Contest_163 #2025_08_17_Time_0_ms_(100.00%)_Space_41.03_MB_(100.00%)
+
+public class Solution {
+    public int minSensors(int n, int m, int k) {
+        int size = k * 2 + 1;
+        int x = n / size + (n % size == 0 ? 0 : 1);
+        int y = m / size + (m % size == 0 ? 0 : 1);
+        return x * y;
+    }
+}

src/main/java/g3601_3700/s3648_minimum_sensors_to_cover_grid/readme.md

@@ -0,0 +1,37 @@
+3648\. Minimum Sensors to Cover Grid
+
+Medium
+
+You are given `n × m` grid and an integer `k`.
+
+A sensor placed on cell `(r, c)` covers all cells whose **Chebyshev distance** from `(r, c)` is **at most** `k`.
+
+The **Chebyshev distance** between two cells <code>(r<sub>1</sub>, c<sub>1</sub>)</code> and <code>(r<sub>2</sub>, c<sub>2</sub>)</code> is <code>max(|r<sub>1</sub> − r<sub>2</sub>|,|c<sub>1</sub> − c<sub>2</sub>|)</code>.
+
+Your task is to return the **minimum** number of sensors required to cover every cell of the grid.
+
+**Example 1:**
+
+**Input:** n = 5, m = 5, k = 1
+
+**Output:** 4
+
+**Explanation:**
+
+Placing sensors at positions `(0, 3)`, `(1, 0)`, `(3, 3)`, and `(4, 1)` ensures every cell in the grid is covered. Thus, the answer is 4.
+
+**Example 2:**
+
+**Input:** n = 2, m = 2, k = 2
+
+**Output:** 1
+
+**Explanation:**
+
+With `k = 2`, a single sensor can cover the entire `2 * 2` grid regardless of its position. Thus, the answer is 1.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>3</sup></code>
+*   <code>1 <= m <= 10<sup>3</sup></code>
+*   <code>0 <= k <= 10<sup>3</sup></code>

src/main/java/g3601_3700/s3649_number_of_perfect_pairs/Solution.java

@@ -0,0 +1,28 @@
+package g3601_3700.s3649_number_of_perfect_pairs;
+
+// #Medium #Biweekly_Contest_163 #2025_08_17_Time_46_ms_(100.00%)_Space_60.00_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long perfectPairs(int[] nums) {
+        int n = nums.length;
+        long[] arr = new long[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Math.abs((long) nums[i]);
+        }
+        Arrays.sort(arr);
+        long cnt = 0;
+        int r = 0;
+        for (int i = 0; i < n; i++) {
+            if (r < i) {
+                r = i;
+            }
+            while (r + 1 < n && arr[r + 1] <= 2 * arr[i]) {
+                r++;
+            }
+            cnt += (r - i);
+        }
+        return cnt;
+    }
+}

src/main/java/g3601_3700/s3649_number_of_perfect_pairs/readme.md

@@ -0,0 +1,63 @@
+3649\. Number of Perfect Pairs
+
+Medium
+
+You are given an integer array `nums`.
+
+A pair of indices `(i, j)` is called **perfect** if the following conditions are satisfied:
+
+*   `i < j`
+*   Let `a = nums[i]`, `b = nums[j]`. Then:
+    *   `min(|a - b|, |a + b|) <= min(|a|, |b|)`
+    *   `max(|a - b|, |a + b|) >= max(|a|, |b|)`
+
+Return the number of **distinct** perfect pairs.
+
+**Note:** The absolute value `|x|` refers to the **non-negative** value of `x`.
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,3]
+
+**Output:** 2
+
+**Explanation:**
+
+There are 2 perfect pairs:
+
+| `(i, j)` | `(a, b)`  | `min(|a − b|, |a + b|)`             | `min(|a|, |b|)` | `max(|a − b|, |a + b|)`             | `max(|a|, |b|)` |
+|----------|-----------|-------------------------------------|-----------------|-------------------------------------|-----------------|
+| (1, 2)   | (1, 2)    | `min(|1 − 2|, |1 + 2|) = 1`         | 1               | `max(|1 − 2|, |1 + 2|) = 3`         | 2               |
+| (2, 3)   | (2, 3)    | `min(|2 − 3|, |2 + 3|) = 1`         | 2               | `max(|2 − 3|, |2 + 3|) = 5`         | 3               |
+
+**Example 2:**
+
+**Input:** nums = [-3,2,-1,4]
+
+**Output:** 4
+
+**Explanation:**
+
+There are 4 perfect pairs:
+
+| `(i, j)` | `(a, b)`  | `min(|a − b|, |a + b|)`                       | `min(|a|, |b|)` | `max(|a − b|, |a + b|)`                       | `max(|a|, |b|)` |
+|----------|-----------|-----------------------------------------------|-----------------|-----------------------------------------------|-----------------|
+| (0, 1)   | (-3, 2)   | `min(|-3 - 2|, |-3 + 2|) = 1`                 | 2               | `max(|-3 - 2|, |-3 + 2|) = 5`                 | 3               |
+| (0, 3)   | (-3, 4)   | `min(|-3 - 4|, |-3 + 4|) = 1`                 | 3               | `max(|-3 - 4|, |-3 + 4|) = 7`                 | 4               |
+| (1, 2)   | (2, -1)   | `min(|2 - (-1)|, |2 + (-1)|) = 1`             | 1               | `max(|2 - (-1)|, |2 + (-1)|) = 3`             | 2               |
+| (1, 3)   | (2, 4)    | `min(|2 - 4|, |2 + 4|) = 2`                   | 2               | `max(|2 - 4|, |2 + 4|) = 6`                   | 4               |
+
+**Example 3:**
+
+**Input:** nums = [1,10,100,1000]
+
+**Output:** 0
+
+**Explanation:**
+
+There are no perfect pairs. Thus, the answer is 0.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g3601_3700/s3650_minimum_cost_path_with_edge_reversals/Solution.java

@@ -0,0 +1,87 @@
+package g3601_3700.s3650_minimum_cost_path_with_edge_reversals;
+
+// #Medium #Biweekly_Contest_163 #2025_08_17_Time_51_ms_(99.85%)_Space_110.03_MB_(49.54%)
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+@SuppressWarnings({"java:S1210", "java:S2234"})
+public class Solution {
+    private static final int INF = Integer.MAX_VALUE / 2 - 1;
+    private int cnt;
+    private int[] head;
+    private int[] next;
+    private int[] to;
+    private int[] weight;
+
+    private static class Dist implements Comparable<Dist> {
+        int u;
+        int d;
+
+        public Dist(int u, int d) {
+            this.u = u;
+            this.d = d;
+        }
+
+        @Override
+        public int compareTo(Dist o) {
+            return Long.compare(d, o.d);
+        }
+    }
+
+    private void init(int n, int m) {
+        head = new int[n];
+        Arrays.fill(head, -1);
+        next = new int[m];
+        to = new int[m];
+        weight = new int[m];
+    }
+
+    private void add(int u, int v, int w) {
+        to[cnt] = v;
+        weight[cnt] = w;
+        next[cnt] = head[u];
+        head[u] = cnt++;
+    }
+
+    private int dist(int s, int t, int n) {
+        PriorityQueue<Dist> queue = new PriorityQueue<>();
+        int[] dist = new int[n];
+        Arrays.fill(dist, INF);
+        dist[s] = 0;
+        queue.add(new Dist(s, dist[s]));
+        while (!queue.isEmpty()) {
+            Dist d = queue.remove();
+            int u = d.u;
+            if (dist[u] < d.d) {
+                continue;
+            }
+            if (u == t) {
+                return dist[t];
+            }
+            for (int i = head[u]; i != -1; i = next[i]) {
+                int v = to[i];
+                int w = weight[i];
+                if (dist[v] > dist[u] + w) {
+                    dist[v] = dist[u] + w;
+                    queue.add(new Dist(v, dist[v]));
+                }
+            }
+        }
+        return INF;
+    }
+
+    public int minCost(int n, int[][] edges) {
+        int m = edges.length;
+        init(n, 2 * m);
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            int w = edge[2];
+            add(u, v, w);
+            add(v, u, 2 * w);
+        }
+        int ans = dist(0, n - 1, n);
+        return ans == INF ? -1 : ans;
+    }
+}

src/main/java/g3601_3700/s3650_minimum_cost_path_with_edge_reversals/readme.md

@@ -0,0 +1,44 @@
+3650\. Minimum Cost Path with Edge Reversals
+
+Medium
+
+You are given a directed, weighted graph with `n` nodes labeled from 0 to `n - 1`, and an array `edges` where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> represents a directed edge from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code> with cost <code>w<sub>i</sub></code>.
+
+Each node <code>u<sub>i</sub></code> has a switch that can be used **at most once**: when you arrive at <code>u<sub>i</sub></code> and have not yet used its switch, you may activate it on one of its incoming edges <code>v<sub>i</sub> → u<sub>i</sub></code> reverse that edge to <code>u<sub>i</sub> → v<sub>i</sub></code> and **immediately** traverse it.
+
+The reversal is only valid for that single move, and using a reversed edge costs <code>2 * w<sub>i</sub></code>.
+
+Return the **minimum** total cost to travel from node 0 to node `n - 1`. If it is not possible, return -1.
+
+**Example 1:**
+
+**Input:** n = 4, edges = [[0,1,3],[3,1,1],[2,3,4],[0,2,2]]
+
+**Output:** 5
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2025/05/07/e1drawio.png)**
+
+*   Use the path `0 → 1` (cost 3).
+*   At node 1 reverse the original edge `3 → 1` into `1 → 3` and traverse it at cost `2 * 1 = 2`.
+*   Total cost is `3 + 2 = 5`.
+
+**Example 2:**
+
+**Input:** n = 4, edges = [[0,2,1],[2,1,1],[1,3,1],[2,3,3]]
+
+**Output:** 3
+
+**Explanation:**
+
+*   No reversal is needed. Take the path `0 → 2` (cost 1), then `2 → 1` (cost 1), then `1 → 3` (cost 1).
+*   Total cost is `1 + 1 + 1 = 3`.
+
+**Constraints:**
+
+*   <code>2 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= edges.length <= 10<sup>5</sup></code>
+*   <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code>
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> <= n - 1</code>
+*   <code>1 <= w<sub>i</sub> <= 1000</code>

src/main/java/g3601_3700/s3651_minimum_cost_path_with_teleportations/Solution.java

@@ -0,0 +1,70 @@
+package g3601_3700.s3651_minimum_cost_path_with_teleportations;
+
+// #Hard #Biweekly_Contest_163 #2025_08_17_Time_78_ms_(100.00%)_Space_45.52_MB_(97.73%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minCost(int[][] grid, int k) {
+        int n = grid.length;
+        int m = grid[0].length;
+        int max = -1;
+        int[][] dp = new int[n][m];
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = m - 1; j >= 0; j--) {
+                max = Math.max(grid[i][j], max);
+                if (i == n - 1 && j == m - 1) {
+                    continue;
+                }
+                if (i == n - 1) {
+                    dp[i][j] = grid[i][j + 1] + dp[i][j + 1];
+                } else if (j == m - 1) {
+                    dp[i][j] = grid[i + 1][j] + dp[i + 1][j];
+                } else {
+                    dp[i][j] =
+                            Math.min(grid[i + 1][j] + dp[i + 1][j], grid[i][j + 1] + dp[i][j + 1]);
+                }
+            }
+        }
+        int[] prev = new int[max + 1];
+        Arrays.fill(prev, Integer.MAX_VALUE);
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                prev[grid[i][j]] = Math.min(prev[grid[i][j]], dp[i][j]);
+            }
+        }
+        // int currcost = prev[0];
+        for (int i = 1; i <= max; i++) {
+            prev[i] = Math.min(prev[i], prev[i - 1]);
+        }
+        for (int tr = 1; tr <= k; tr++) {
+            for (int i = n - 1; i >= 0; i--) {
+                for (int j = m - 1; j >= 0; j--) {
+                    if (i == n - 1 && j == m - 1) {
+                        continue;
+                    }
+                    dp[i][j] = prev[grid[i][j]];
+                    if (i == n - 1) {
+                        dp[i][j] = Math.min(dp[i][j], grid[i][j + 1] + dp[i][j + 1]);
+                    } else if (j == m - 1) {
+                        dp[i][j] = Math.min(dp[i][j], grid[i + 1][j] + dp[i + 1][j]);
+                    } else {
+                        dp[i][j] = Math.min(dp[i][j], grid[i + 1][j] + dp[i + 1][j]);
+                        dp[i][j] = Math.min(dp[i][j], grid[i][j + 1] + dp[i][j + 1]);
+                    }
+                }
+            }
+            Arrays.fill(prev, Integer.MAX_VALUE);
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    prev[grid[i][j]] = Math.min(prev[grid[i][j]], dp[i][j]);
+                }
+            }
+            // int currcost = prev[0];
+            for (int i = 1; i <= max; i++) {
+                prev[i] = Math.min(prev[i], prev[i - 1]);
+            }
+        }
+        return dp[0][0];
+    }
+}