Added tasks 3527-3534

Author: javadev

README.md

@@ -2088,6 +2088,14 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3534 |[Path Existence Queries in a Graph II](src/main/kotlin/g3501_3600/s3534_path_existence_queries_in_a_graph_ii)| Hard | Array, Sorting, Greedy, Binary_Search, Graph | 152 | 100.00
+| 3533 |[Concatenated Divisibility](src/main/kotlin/g3501_3600/s3533_concatenated_divisibility)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 20 | 100.00
+| 3532 |[Path Existence Queries in a Graph I](src/main/kotlin/g3501_3600/s3532_path_existence_queries_in_a_graph_i)| Medium | Array, Binary_Search, Graph, Union_Find | 5 | 90.91
+| 3531 |[Count Covered Buildings](src/main/kotlin/g3501_3600/s3531_count_covered_buildings)| Medium | Array, Hash_Table, Sorting | 34 | 100.00
+| 3530 |[Maximum Profit from Valid Topological Order in DAG](src/main/kotlin/g3501_3600/s3530_maximum_profit_from_valid_topological_order_in_dag)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Graph, Bitmask, Topological_Sort | 833 | 100.00
+| 3529 |[Count Cells in Overlapping Horizontal and Vertical Substrings](src/main/kotlin/g3501_3600/s3529_count_cells_in_overlapping_horizontal_and_vertical_substrings)| Medium | Array, String, Matrix, Hash_Function, String_Matching, Rolling_Hash | 51 | 100.00
+| 3528 |[Unit Conversion I](src/main/kotlin/g3501_3600/s3528_unit_conversion_i)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 3 | 100.00
+| 3527 |[Find the Most Common Response](src/main/kotlin/g3501_3600/s3527_find_the_most_common_response)| Medium | Array, String, Hash_Table, Counting | 73 | 100.00
 | 3525 |[Find X Value of Array II](src/main/kotlin/g3501_3600/s3525_find_x_value_of_array_ii)| Hard | Array, Math, Segment_Tree | 237 | 50.00
 | 3524 |[Find X Value of Array I](src/main/kotlin/g3501_3600/s3524_find_x_value_of_array_i)| Medium | Array, Dynamic_Programming, Math | 12 | 100.00
 | 3523 |[Make Array Non-decreasing](src/main/kotlin/g3501_3600/s3523_make_array_non_decreasing)| Medium | Array, Greedy, Stack, Monotonic_Stack | 4 | 75.00

src/main/kotlin/g3501_3600/s3527_find_the_most_common_response/readme.md

@@ -0,0 +1,90 @@
+[![](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)
+
+## 3527\. Find the Most Common Response
+
+Medium
+
+You are given a 2D string array `responses` where each `responses[i]` is an array of strings representing survey responses from the <code>i<sup>th</sup></code> day.
+
+Return the **most common** response across all days after removing **duplicate** responses within each `responses[i]`. If there is a tie, return the _lexicographically smallest_ response.
+
+**Example 1:**
+
+**Input:** responses = \[\["good","ok","good","ok"],["ok","bad","good","ok","ok"],["good"],["bad"]]
+
+**Output:** "good"
+
+**Explanation:**
+
+*   After removing duplicates within each list, `responses = \[\["good", "ok"], ["ok", "bad", "good"], ["good"], ["bad"]]`.
+*   `"good"` appears 3 times, `"ok"` appears 2 times, and `"bad"` appears 2 times.
+*   Return `"good"` because it has the highest frequency.
+
+**Example 2:**
+
+**Input:** responses = \[\["good","ok","good"],["ok","bad"],["bad","notsure"],["great","good"]]
+
+**Output:** "bad"
+
+**Explanation:**
+
+*   After removing duplicates within each list we have `responses = \[\["good", "ok"], ["ok", "bad"], ["bad", "notsure"], ["great", "good"]]`.
+*   `"bad"`, `"good"`, and `"ok"` each occur 2 times.
+*   The output is `"bad"` because it is the lexicographically smallest amongst the words with the highest frequency.
+
+**Constraints:**
+
+*   `1 <= responses.length <= 1000`
+*   `1 <= responses[i].length <= 1000`
+*   `1 <= responses[i][j].length <= 10`
+*   `responses[i][j]` consists of only lowercase English letters
+
+## Solution
+
+```kotlin
+class Solution {
+    private fun compareStrings(str1: String, str2: String): Boolean {
+        val n = str1.length
+        val m = str2.length
+        var i = 0
+        var j = 0
+        while (i < n && j < m) {
+            if (str1[i] < str2[j]) {
+                return true
+            } else if (str1[i] > str2[j]) {
+                return false
+            }
+            i++
+            j++
+        }
+        return n < m
+    }
+
+    fun findCommonResponse(responses: List<List<String>>): String {
+        val n = responses.size
+        val mp: MutableMap<String, IntArray> = HashMap()
+        var ans = responses[0][0]
+        var maxFreq = 0
+        for (row in 0..<n) {
+            val m = responses[row].size
+            for (col in 0..<m) {
+                val resp = responses[row][col]
+                val arr = mp.getOrDefault(resp, intArrayOf(0, -1))
+                if (arr[1] != row) {
+                    arr[0]++
+                    arr[1] = row
+                    mp.put(resp, arr)
+                }
+                if (arr[0] > maxFreq ||
+                    (ans != resp) && arr[0] == maxFreq && compareStrings(resp, ans)
+                ) {
+                    ans = resp
+                    maxFreq = arr[0]
+                }
+            }
+        }
+        return ans
+    }
+}
+```

src/main/kotlin/g3501_3600/s3528_unit_conversion_i/readme.md

@@ -0,0 +1,63 @@
+[![](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)
+
+## 3528\. Unit Conversion I
+
+Medium
+
+There are `n` types of units indexed from `0` to `n - 1`. You are given a 2D integer array `conversions` of length `n - 1`, where <code>conversions[i] = [sourceUnit<sub>i</sub>, targetUnit<sub>i</sub>, conversionFactor<sub>i</sub>]</code>. This indicates that a single unit of type <code>sourceUnit<sub>i</sub></code> is equivalent to <code>conversionFactor<sub>i</sub></code> units of type <code>targetUnit<sub>i</sub></code>.
+
+Return an array `baseUnitConversion` of length `n`, where `baseUnitConversion[i]` is the number of units of type `i` equivalent to a single unit of type 0. Since the answer may be large, return each `baseUnitConversion[i]` **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** conversions = \[\[0,1,2],[1,2,3]]
+
+**Output:** [1,2,6]
+
+**Explanation:**
+
+*   Convert a single unit of type 0 into 2 units of type 1 using `conversions[0]`.
+*   Convert a single unit of type 0 into 6 units of type 2 using `conversions[0]`, then `conversions[1]`.
+
+![](https://assets.leetcode.com/uploads/2025/03/12/example1.png)
+
+**Example 2:**
+
+**Input:** conversions = \[\[0,1,2],[0,2,3],[1,3,4],[1,4,5],[2,5,2],[4,6,3],[5,7,4]]
+
+**Output:** [1,2,3,8,10,6,30,24]
+
+**Explanation:**
+
+*   Convert a single unit of type 0 into 2 units of type 1 using `conversions[0]`.
+*   Convert a single unit of type 0 into 3 units of type 2 using `conversions[1]`.
+*   Convert a single unit of type 0 into 8 units of type 3 using `conversions[0]`, then `conversions[2]`.
+*   Convert a single unit of type 0 into 10 units of type 4 using `conversions[0]`, then `conversions[3]`.
+*   Convert a single unit of type 0 into 6 units of type 5 using `conversions[1]`, then `conversions[4]`.
+*   Convert a single unit of type 0 into 30 units of type 6 using `conversions[0]`, `conversions[3]`, then `conversions[5]`.
+*   Convert a single unit of type 0 into 24 units of type 7 using `conversions[1]`, `conversions[4]`, then `conversions[6]`.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `conversions.length == n - 1`
+*   <code>0 <= sourceUnit<sub>i</sub>, targetUnit<sub>i</sub> < n</code>
+*   <code>1 <= conversionFactor<sub>i</sub> <= 10<sup>9</sup></code>
+*   It is guaranteed that unit 0 can be converted into any other unit through a **unique** combination of conversions without using any conversions in the opposite direction.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun baseUnitConversions(conversions: Array<IntArray>): IntArray {
+        val arr = IntArray(conversions.size + 1)
+        arr[0] = 1
+        for (conversion in conversions) {
+            val `val` = (arr[conversion[0]].toLong() * conversion[2]) % 1000000007
+            arr[conversion[1]] = `val`.toInt()
+        }
+        return arr
+    }
+}
+```

src/main/kotlin/g3501_3600/s3529_count_cells_in_overlapping_horizontal_and_vertical_substrings/readme.md

@@ -0,0 +1,148 @@
+[![](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)
+
+## 3529\. Count Cells in Overlapping Horizontal and Vertical Substrings
+
+Medium
+
+You are given an `m x n` matrix `grid` consisting of characters and a string `pattern`.
+
+A **horizontal substring** is a contiguous sequence of characters read from left to right. If the end of a row is reached before the substring is complete, it wraps to the first column of the next row and continues as needed. You do **not** wrap from the bottom row back to the top.
+
+A **vertical substring** is a contiguous sequence of characters read from top to bottom. If the bottom of a column is reached before the substring is complete, it wraps to the first row of the next column and continues as needed. You do **not** wrap from the last column back to the first.
+
+Count the number of cells in the matrix that satisfy the following condition:
+
+*   The cell must be part of **at least** one horizontal substring and **at least** one vertical substring, where **both** substrings are equal to the given `pattern`.
+
+Return the count of these cells.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2025/03/03/gridtwosubstringsdrawio.png)
+
+**Input:** grid = \[\["a","a","c","c"],["b","b","b","c"],["a","a","b","a"],["c","a","a","c"],["a","a","c","c"]], pattern = "abaca"
+
+**Output:** 1
+
+**Explanation:**
+
+The pattern `"abaca"` appears once as a horizontal substring (colored blue) and once as a vertical substring (colored red), intersecting at one cell (colored purple).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2025/03/03/gridexample2fixeddrawio.png)
+
+**Input:** grid = \[\["c","a","a","a"],["a","a","b","a"],["b","b","a","a"],["a","a","b","a"]], pattern = "aba"
+
+**Output:** 4
+
+**Explanation:**
+
+The cells colored above are all part of at least one horizontal and one vertical substring matching the pattern `"aba"`.
+
+**Example 3:**
+
+**Input:** grid = \[\["a"]], pattern = "a"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 1000`
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `1 <= pattern.length <= m * n`
+*   `grid` and `pattern` consist of only lowercase English letters.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun countCells(grid: Array<CharArray>, pattern: String): Int {
+        val k = pattern.length
+        val lps = makeLps(pattern)
+        val m = grid.size
+        val n = grid[0].size
+        val horiPats = Array(m) { IntArray(n) }
+        val vertPats = Array(m) { IntArray(n) }
+        var i = 0
+        var j = 0
+        while (i < m * n) {
+            if (grid[i / n][i % n] == pattern[j]) {
+                i++
+                if (++j == k) {
+                    val d = i - j
+                    horiPats[d / n][d % n] = horiPats[d / n][d % n] + 1
+                    if (i < m * n) {
+                        horiPats[i / n][i % n] = horiPats[i / n][i % n] - 1
+                    }
+                    j = lps[j - 1]
+                }
+            } else if (j != 0) {
+                j = lps[j - 1]
+            } else {
+                i++
+            }
+        }
+        i = 0
+        j = 0
+        // now do vert pattern, use i = 0 to m*n -1 but instead index as grid[i % m][i/m]
+        while (i < m * n) {
+            if (grid[i % m][i / m] == pattern[j]) {
+                i++
+                if (++j == k) {
+                    val d = i - j
+                    vertPats[d % m][d / m] = vertPats[d % m][d / m] + 1
+                    if (i < m * n) {
+                        vertPats[i % m][i / m] = vertPats[i % m][i / m] - 1
+                    }
+                    j = lps[j - 1]
+                }
+            } else if (j != 0) {
+                j = lps[j - 1]
+            } else {
+                i++
+            }
+        }
+        i = 1
+        while (i < m * n) {
+            vertPats[i % m][i / m] += vertPats[(i - 1) % m][(i - 1) / m]
+            horiPats[i / n][i % n] += horiPats[(i - 1) / n][(i - 1) % n]
+            i++
+        }
+        var res = 0
+        i = 0
+        while (i < m) {
+            j = 0
+            while (j < n) {
+                if (horiPats[i][j] > 0 && vertPats[i][j] > 0) {
+                    res++
+                }
+                j++
+            }
+            i++
+        }
+        return res
+    }
+
+    private fun makeLps(pattern: String): IntArray {
+        val n = pattern.length
+        val lps = IntArray(n)
+        var len = 0
+        var i = 1
+        lps[0] = 0
+        while (i < n) {
+            if (pattern[i] == pattern[len]) {
+                lps[i++] = ++len
+            } else if (len != 0) {
+                len = lps[len - 1]
+            } else {
+                lps[i++] = 0
+            }
+        }
+        return lps
+    }
+}
+```