Added tasks 3238-3251

Author: javadev

README.md

@@ -1816,6 +1816,18 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3251 |[Find the Count of Monotonic Pairs II](src/main/kotlin/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii)| Hard | Array, Dynamic_Programming, Math, Prefix_Sum, Combinatorics | 291 | 100.00
+| 3250 |[Find the Count of Monotonic Pairs I](src/main/kotlin/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i)| Hard | Array, Dynamic_Programming, Math, Prefix_Sum, Combinatorics | 241 | 100.00
+| 3249 |[Count the Number of Good Nodes](src/main/kotlin/g3201_3300/s3249_count_the_number_of_good_nodes)| Medium | Depth_First_Search, Tree | 1190 | 100.00
+| 3248 |[Snake in Matrix](src/main/kotlin/g3201_3300/s3248_snake_in_matrix)| Easy | Array, String, Simulation | 174 | 90.91
+| 3245 |[Alternating Groups III](src/main/kotlin/g3201_3300/s3245_alternating_groups_iii)| Hard | Array, Binary_Indexed_Tree | 1072 | 100.00
+| 3244 |[Shortest Distance After Road Addition Queries II](src/main/kotlin/g3201_3300/s3244_shortest_distance_after_road_addition_queries_ii)| Hard | Array, Greedy, Graph, Ordered_Set | 794 | 92.31
+| 3243 |[Shortest Distance After Road Addition Queries I](src/main/kotlin/g3201_3300/s3243_shortest_distance_after_road_addition_queries_i)| Medium | Array, Breadth_First_Search, Graph | 313 | 97.06
+| 3242 |[Design Neighbor Sum Service](src/main/kotlin/g3201_3300/s3242_design_neighbor_sum_service)| Easy | Array, Hash_Table, Matrix, Design, Simulation | 333 | 75.00
+| 3241 |[Time Taken to Mark All Nodes](src/main/kotlin/g3201_3300/s3241_time_taken_to_mark_all_nodes)| Hard | Dynamic_Programming, Depth_First_Search, Tree, Graph | 1228 | 100.00
+| 3240 |[Minimum Number of Flips to Make Binary Grid Palindromic II](src/main/kotlin/g3201_3300/s3240_minimum_number_of_flips_to_make_binary_grid_palindromic_ii)| Medium | Array, Matrix, Two_Pointers | 805 | 100.00
+| 3239 |[Minimum Number of Flips to Make Binary Grid Palindromic I](src/main/kotlin/g3201_3300/s3239_minimum_number_of_flips_to_make_binary_grid_palindromic_i)| Medium | Array, Matrix, Two_Pointers | 856 | 87.50
+| 3238 |[Find the Number of Winning Players](src/main/kotlin/g3201_3300/s3238_find_the_number_of_winning_players)| Easy | Array, Hash_Table, Counting | 207 | 90.38
 | 3235 |[Check if the Rectangle Corner Is Reachable](src/main/kotlin/g3201_3300/s3235_check_if_the_rectangle_corner_is_reachable)| Hard | Array, Math, Depth_First_Search, Breadth_First_Search, Union_Find, Geometry | 612 | 66.67
 | 3234 |[Count the Number of Substrings With Dominant Ones](src/main/kotlin/g3201_3300/s3234_count_the_number_of_substrings_with_dominant_ones)| Medium | String, Sliding_Window, Enumeration | 356 | 100.00
 | 3233 |[Find the Count of Numbers Which Are Not Special](src/main/kotlin/g3201_3300/s3233_find_the_count_of_numbers_which_are_not_special)| Medium | Array, Math, Number_Theory | 215 | 76.19

src/main/kotlin/g3201_3300/s3238_find_the_number_of_winning_players/readme.md

@@ -0,0 +1,87 @@
+[![](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)
+
+## 3238\. Find the Number of Winning Players
+
+Easy
+
+You are given an integer `n` representing the number of players in a game and a 2D array `pick` where <code>pick[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents that the player <code>x<sub>i</sub></code> picked a ball of color <code>y<sub>i</sub></code>.
+
+Player `i` **wins** the game if they pick **strictly more** than `i` balls of the **same** color. In other words,
+
+*   Player 0 wins if they pick any ball.
+*   Player 1 wins if they pick at least two balls of the _same_ color.
+*   ...
+*   Player `i` wins if they pick at least`i + 1` balls of the _same_ color.
+
+Return the number of players who **win** the game.
+
+**Note** that _multiple_ players can win the game.
+
+**Example 1:**
+
+**Input:** n = 4, pick = \[\[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
+
+**Output:** 2
+
+**Explanation:**
+
+Player 0 and player 1 win the game, while players 2 and 3 do not win.
+
+**Example 2:**
+
+**Input:** n = 5, pick = \[\[1,1],[1,2],[1,3],[1,4]]
+
+**Output:** 0
+
+**Explanation:**
+
+No player wins the game.
+
+**Example 3:**
+
+**Input:** n = 5, pick = \[\[1,1],[2,4],[2,4],[2,4]]
+
+**Output:** 1
+
+**Explanation:**
+
+Player 2 wins the game by picking 3 balls with color 4.
+
+**Constraints:**
+
+*   `2 <= n <= 10`
+*   `1 <= pick.length <= 100`
+*   `pick[i].length == 2`
+*   <code>0 <= x<sub>i</sub> <= n - 1</code>
+*   <code>0 <= y<sub>i</sub> <= 10</code>
+
+## Solution
+
+```kotlin
+@Suppress("UNUSED_PARAMETER")
+class Solution {
+    fun winningPlayerCount(n: Int, pick: Array<IntArray>): Int {
+        val dp = Array(11) { IntArray(11) }
+        for (ints in pick) {
+            val p = ints[0]
+            val pi = ints[1]
+            dp[p][pi] += 1
+        }
+        var count = 0
+        for (i in 0..10) {
+            var win = false
+            for (j in 0..10) {
+                if (dp[i][j] >= i + 1) {
+                    win = true
+                    break
+                }
+            }
+            if (win) {
+                count += 1
+            }
+        }
+        return count
+    }
+}
+```

src/main/kotlin/g3201_3300/s3239_minimum_number_of_flips_to_make_binary_grid_palindromic_i/readme.md

@@ -0,0 +1,83 @@
+[![](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)
+
+## 3239\. Minimum Number of Flips to Make Binary Grid Palindromic I
+
+Medium
+
+You are given an `m x n` binary matrix `grid`.
+
+A row or column is considered **palindromic** if its values read the same forward and backward.
+
+You can **flip** any number of cells in `grid` from `0` to `1`, or from `1` to `0`.
+
+Return the **minimum** number of cells that need to be flipped to make **either** all rows **palindromic** or all columns **palindromic**.
+
+**Example 1:**
+
+**Input:** grid = \[\[1,0,0],[0,0,0],[0,0,1]]
+
+**Output:** 2
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/07/screenshot-from-2024-07-08-00-20-10.png)
+
+Flipping the highlighted cells makes all the rows palindromic.
+
+**Example 2:**
+
+**Input:** grid = \[\[0,1],[0,1],[0,0]]
+
+**Output:** 1
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/07/screenshot-from-2024-07-08-00-31-23.png)
+
+Flipping the highlighted cell makes all the columns palindromic.
+
+**Example 3:**
+
+**Input:** grid = \[\[1],[0]]
+
+**Output:** 0
+
+**Explanation:**
+
+All rows are already palindromic.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m * n <= 2 * 10<sup>5</sup></code>
+*   `0 <= grid[i][j] <= 1`
+
+## Solution
+
+```kotlin
+import kotlin.math.min
+
+class Solution {
+    fun minFlips(grid: Array<IntArray>): Int {
+        val m = grid.size
+        val n = grid[0].size
+        var rowFlips = 0
+        for (i in 0 until m / 2) {
+            for (j in 0 until n) {
+                val sum = grid[i][j] + grid[m - 1 - i][j]
+                rowFlips += min(sum, (2 - sum))
+            }
+        }
+        var columnFlips = 0
+        for (j in 0 until n / 2) {
+            for (ints in grid) {
+                val sum = ints[j] + ints[n - 1 - j]
+                columnFlips += min(sum, (2 - sum))
+            }
+        }
+        return min(rowFlips, columnFlips)
+    }
+}
+```

src/main/kotlin/g3201_3300/s3240_minimum_number_of_flips_to_make_binary_grid_palindromic_ii/readme.md

@@ -0,0 +1,103 @@
+[![](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)
+
+## 3240\. Minimum Number of Flips to Make Binary Grid Palindromic II
+
+Medium
+
+You are given an `m x n` binary matrix `grid`.
+
+A row or column is considered **palindromic** if its values read the same forward and backward.
+
+You can **flip** any number of cells in `grid` from `0` to `1`, or from `1` to `0`.
+
+Return the **minimum** number of cells that need to be flipped to make **all** rows and columns **palindromic**, and the total number of `1`'s in `grid` **divisible** by `4`.
+
+**Example 1:**
+
+**Input:** grid = \[\[1,0,0],[0,1,0],[0,0,1]]
+
+**Output:** 3
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/08/01/image.png)
+
+**Example 2:**
+
+**Input:** grid = \[\[0,1],[0,1],[0,0]]
+
+**Output:** 2
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/08/screenshot-from-2024-07-09-01-37-48.png)
+
+**Example 3:**
+
+**Input:** grid = \[\[1],[1]]
+
+**Output:** 2
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/08/01/screenshot-from-2024-08-01-23-05-26.png)
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m * n <= 2 * 10<sup>5</sup></code>
+*   `0 <= grid[i][j] <= 1`
+
+## Solution
+
+```kotlin
+import kotlin.math.min
+
+class Solution {
+    fun minFlips(grid: Array<IntArray>): Int {
+        var res = 0
+        var one = 0
+        var diff = 0
+        val m = grid.size
+        val n = grid[0].size
+        // Handle quadrants
+        for (i in 0 until m / 2) {
+            for (j in 0 until n / 2) {
+                val v =
+                    (
+                        grid[i][j] +
+                            grid[i][n - 1 - j] +
+                            grid[m - 1 - i][j] +
+                            grid[m - 1 - i][n - 1 - j]
+                        )
+                res += min(v, (4 - v))
+            }
+        }
+        // Handle middle column
+        if (n % 2 > 0) {
+            for (i in 0 until m / 2) {
+                diff += grid[i][n / 2] xor grid[m - 1 - i][n / 2]
+                one += grid[i][n / 2] + grid[m - 1 - i][n / 2]
+            }
+        }
+        // Handle middle row
+        if (m % 2 > 0) {
+            for (j in 0 until n / 2) {
+                diff += grid[m / 2][j] xor grid[m / 2][n - 1 - j]
+                one += grid[m / 2][j] + grid[m / 2][n - 1 - j]
+            }
+        }
+        // Handle center point
+        if (n % 2 > 0 && m % 2 > 0) {
+            res += grid[m / 2][n / 2]
+        }
+        // Divisible by 4
+        if (diff == 0 && one % 4 > 0) {
+            res += 2
+        }
+        return res + diff
+    }
+}
+```