Added tasks 3648-3655

Author: javadev

README.md

@@ -2088,6 +2088,14 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3655 |[XOR After Range Multiplication Queries II](src/main/kotlin/g3601_3700/s3655_xor_after_range_multiplication_queries_ii)| Hard | Array, Divide_and_Conquer, Weekly_Contest_463 | 26 | 100.00
+| 3654 |[Minimum Sum After Divisible Sum Deletions](src/main/kotlin/g3601_3700/s3654_minimum_sum_after_divisible_sum_deletions)| Medium | Weekly_Contest_463 | 17 | 98.16
+| 3653 |[XOR After Range Multiplication Queries I](src/main/kotlin/g3601_3700/s3653_xor_after_range_multiplication_queries_i)| Medium | Array, Simulation, Divide_and_Conquer, Weekly_Contest_463 | 26 | 100.00
+| 3652 |[Best Time to Buy and Sell Stock using Strategy](src/main/kotlin/g3601_3700/s3652_best_time_to_buy_and_sell_stock_using_strategy)| Medium | Array, Prefix_Sum, Sliding_Window, Weekly_Contest_463 | 6 | 100.00
+| 3651 |[Minimum Cost Path with Teleportations](src/main/kotlin/g3601_3700/s3651_minimum_cost_path_with_teleportations)| Hard | Biweekly_Contest_163 | 78 | 100.00
+| 3650 |[Minimum Cost Path with Edge Reversals](src/main/kotlin/g3601_3700/s3650_minimum_cost_path_with_edge_reversals)| Medium | Biweekly_Contest_163 | 51 | 99.85
+| 3649 |[Number of Perfect Pairs](src/main/kotlin/g3601_3700/s3649_number_of_perfect_pairs)| Medium | Biweekly_Contest_163 | 46 | 100.00
+| 3648 |[Minimum Sensors to Cover Grid](src/main/kotlin/g3601_3700/s3648_minimum_sensors_to_cover_grid)| Medium | Biweekly_Contest_163 | 0 | 100.00
 | 3646 |[Next Special Palindrome Number](src/main/kotlin/g3601_3700/s3646_next_special_palindrome_number)| Hard | Backtracking, Weekly_Contest_462 | 34 | 100.00
 | 3645 |[Maximum Total from Optimal Activation Order](src/main/kotlin/g3601_3700/s3645_maximum_total_from_optimal_activation_order)| Medium | Array, Sorting, Greedy, Two_Pointers, Heap_Priority_Queue, Weekly_Contest_462 | 77 | 100.00
 | 3644 |[Maximum K to Sort a Permutation](src/main/kotlin/g3601_3700/s3644_maximum_k_to_sort_a_permutation)| Medium | Weekly_Contest_462 | 4 | 100.00

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

@@ -0,0 +1,53 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun minSensors(n: Int, m: Int, k: Int): Int {
+        val size = k * 2 + 1
+        val x = n / size + (if (n % size == 0) 0 else 1)
+        val y = m / size + (if (m % size == 0) 0 else 1)
+        return x * y
+    }
+}
+```

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

@@ -0,0 +1,95 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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>
+
+## Solution
+
+```kotlin
+import kotlin.math.abs
+
+class Solution {
+    fun perfectPairs(nums: IntArray): Long {
+        val n = nums.size
+        val arr = LongArray(n)
+        for (i in 0..<n) {
+            arr[i] = abs(nums[i].toLong())
+        }
+        arr.sort()
+        var cnt: Long = 0
+        var r = 0
+        for (i in 0..<n) {
+            if (r < i) {
+                r = i
+            }
+            while (r + 1 < n && arr[r + 1] <= 2 * arr[i]) {
+                r++
+            }
+            cnt += (r - i).toLong()
+        }
+        return cnt
+    }
+}
+```

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

@@ -0,0 +1,129 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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>
+
+## Solution
+
+```kotlin
+import java.util.PriorityQueue
+
+class Solution {
+    private var cnt = 0
+    private lateinit var head: IntArray
+    private lateinit var next: IntArray
+    private lateinit var to: IntArray
+    private lateinit var weight: IntArray
+
+    private class Dist(var u: Int, var d: Int) : Comparable<Dist> {
+        override fun compareTo(other: Dist): Int {
+            return d.toLong().compareTo(other.d.toLong())
+        }
+    }
+
+    private fun init(n: Int, m: Int) {
+        head = IntArray(n)
+        head.fill(-1)
+        next = IntArray(m)
+        to = IntArray(m)
+        weight = IntArray(m)
+    }
+
+    private fun add(u: Int, v: Int, w: Int) {
+        to[cnt] = v
+        weight[cnt] = w
+        next[cnt] = head[u]
+        head[u] = cnt++
+    }
+
+    private fun dist(s: Int, t: Int, n: Int): Int {
+        val queue: PriorityQueue<Dist> = PriorityQueue<Dist>()
+        val dist = IntArray(n)
+        dist.fill(INF)
+        dist[s] = 0
+        queue.add(Dist(s, dist[s]))
+        while (queue.isNotEmpty()) {
+            val d = queue.remove()
+            val u = d.u
+            if (dist[u] < d.d) {
+                continue
+            }
+            if (u == t) {
+                return dist[t]
+            }
+            var i = head[u]
+            while (i != -1) {
+                val v = to[i]
+                val w = weight[i]
+                if (dist[v] > dist[u] + w) {
+                    dist[v] = dist[u] + w
+                    queue.add(Dist(v, dist[v]))
+                }
+                i = next[i]
+            }
+        }
+        return INF
+    }
+
+    fun minCost(n: Int, edges: Array<IntArray>): Int {
+        val m = edges.size
+        init(n, 2 * m)
+        for (edge in edges) {
+            val u = edge[0]
+            val v = edge[1]
+            val w = edge[2]
+            add(u, v, w)
+            add(v, u, 2 * w)
+        }
+        val ans = dist(0, n - 1, n)
+        return if (ans == INF) -1 else ans
+    }
+
+    companion object {
+        private const val INF = Int.Companion.MAX_VALUE / 2 - 1
+    }
+}
+```