Added tasks 3248-3261

Author: javadev

README.md

@@ -1816,15 +1816,27 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3261 |[Count Substrings That Satisfy K-Constraint II](src/main/java/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii)| Hard | Array, String, Binary_Search, Prefix_Sum, Sliding_Window | 8 | 100.00
+| 3260 |[Find the Largest Palindrome Divisible by K](src/main/java/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k)| Hard | String, Dynamic_Programming, Math, Greedy, Number_Theory | 4 | 97.21
+| 3259 |[Maximum Energy Boost From Two Drinks](src/main/java/g3201_3300/s3259_maximum_energy_boost_from_two_drinks)| Medium | Array, Dynamic_Programming | 3 | 100.00
+| 3258 |[Count Substrings That Satisfy K-Constraint I](src/main/java/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i)| Easy | String, Sliding_Window | 1 | 100.00
+| 3257 |[Maximum Value Sum by Placing Three Rooks II](src/main/java/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii)| Hard | Array, Dynamic_Programming, Matrix, Enumeration | 18 | 99.59
+| 3256 |[Maximum Value Sum by Placing Three Rooks I](src/main/java/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i)| Hard | Array, Dynamic_Programming, Matrix, Enumeration | 7 | 100.00
+| 3255 |[Find the Power of K-Size Subarrays II](src/main/java/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii)| Medium | Array, Sliding_Window | 3 | 99.24
+| 3254 |[Find the Power of K-Size Subarrays I](src/main/java/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i)| Medium | Array, Sliding_Window | 1 | 100.00
+| 3251 |[Find the Count of Monotonic Pairs II](src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii)| Hard | Array, Dynamic_Programming, Math, Prefix_Sum, Combinatorics | 24 | 100.00
+| 3250 |[Find the Count of Monotonic Pairs I](src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i)| Hard | Array, Dynamic_Programming, Math, Prefix_Sum, Combinatorics | 3 | 100.00
+| 3249 |[Count the Number of Good Nodes](src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes)| Medium | Depth_First_Search, Tree | 34 | 100.00
+| 3248 |[Snake in Matrix](src/main/java/g3201_3300/s3248_snake_in_matrix)| Easy | Array, String, Simulation | 2 | 98.05
 | 3245 |[Alternating Groups III](src/main/java/g3201_3300/s3245_alternating_groups_iii)| Hard | Array, Binary_Indexed_Tree | 36 | 82.22
 | 3244 |[Shortest Distance After Road Addition Queries II](src/main/java/g3201_3300/s3244_shortest_distance_after_road_addition_queries_ii)| Hard | Array, Greedy, Graph, Ordered_Set | 5 | 97.43
-| 3243 |[Shortest Distance After Road Addition Queries I](src/main/java/g3201_3300/s3243_shortest_distance_after_road_addition_queries_i)| Medium | Array, Graph, Breadth_First_Search | 6 | 100.00
+| 3243 |[Shortest Distance After Road Addition Queries I](src/main/java/g3201_3300/s3243_shortest_distance_after_road_addition_queries_i)| Medium | Array, Breadth_First_Search, Graph | 6 | 100.00
 | 3242 |[Design Neighbor Sum Service](src/main/java/g3201_3300/s3242_design_neighbor_sum_service)| Easy | Array, Hash_Table, Matrix, Design, Simulation | 14 | 100.00
-| 3241 |[Time Taken to Mark All Nodes](src/main/java/g3201_3300/s3241_time_taken_to_mark_all_nodes)| Hard | Dynamic_Programming, Tree, Graph, Depth_First_Search | 39 | 100.00
+| 3241 |[Time Taken to Mark All Nodes](src/main/java/g3201_3300/s3241_time_taken_to_mark_all_nodes)| Hard | Dynamic_Programming, Depth_First_Search, Tree, Graph | 39 | 100.00
 | 3240 |[Minimum Number of Flips to Make Binary Grid Palindromic II](src/main/java/g3201_3300/s3240_minimum_number_of_flips_to_make_binary_grid_palindromic_ii)| Medium | Array, Matrix, Two_Pointers | 3 | 96.90
 | 3239 |[Minimum Number of Flips to Make Binary Grid Palindromic I](src/main/java/g3201_3300/s3239_minimum_number_of_flips_to_make_binary_grid_palindromic_i)| Medium | Array, Matrix, Two_Pointers | 3 | 100.00
 | 3238 |[Find the Number of Winning Players](src/main/java/g3201_3300/s3238_find_the_number_of_winning_players)| Easy | Array, Hash_Table, Counting | 1 | 100.00
-| 3235 |[Check if the Rectangle Corner Is Reachable](src/main/java/g3201_3300/s3235_check_if_the_rectangle_corner_is_reachable)| Hard | Array, Math, Union_Find, Geometry, Depth_First_Search, Breadth_First_Search | 95 | 59.46
+| 3235 |[Check if the Rectangle Corner Is Reachable](src/main/java/g3201_3300/s3235_check_if_the_rectangle_corner_is_reachable)| Hard | Array, Math, Depth_First_Search, Breadth_First_Search, Union_Find, Geometry | 95 | 59.46
 | 3234 |[Count the Number of Substrings With Dominant Ones](src/main/java/g3201_3300/s3234_count_the_number_of_substrings_with_dominant_ones)| Medium | String, Sliding_Window, Enumeration | 163 | 93.90
 | 3233 |[Find the Count of Numbers Which Are Not Special](src/main/java/g3201_3300/s3233_find_the_count_of_numbers_which_are_not_special)| Medium | Array, Math, Number_Theory | 20 | 70.12
 | 3232 |[Find if Digit Game Can Be Won](src/main/java/g3201_3300/s3232_find_if_digit_game_can_be_won)| Easy | Array, Math | 0 | 100.00

src/main/java/g3201_3300/s3217_delete_nodes_from_linked_list_present_in_array/readme.md

@@ -57,11 +57,15 @@ No node has value 5.
 ```java
 import com_github_leetcode.ListNode;
 
-
-/**
- * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode() {}
- * ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val;
- * this.next = next; } }
+/*
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
  */
 public class Solution {
     public ListNode modifiedList(int[] nums, ListNode head) {

src/main/java/g3201_3300/s3248_snake_in_matrix/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3248\. Snake in Matrix
+
+Easy
+
+There is a snake in an `n x n` matrix `grid` and can move in **four possible directions**. Each cell in the `grid` is identified by the position: `grid[i][j] = (i * n) + j`.
+
+The snake starts at cell 0 and follows a sequence of commands.
+
+You are given an integer `n` representing the size of the `grid` and an array of strings `commands` where each `command[i]` is either `"UP"`, `"RIGHT"`, `"DOWN"`, and `"LEFT"`. It's guaranteed that the snake will remain within the `grid` boundaries throughout its movement.
+
+Return the position of the final cell where the snake ends up after executing `commands`.
+
+**Example 1:**
+
+**Input:** n = 2, commands = ["RIGHT","DOWN"]
+
+**Output:** 3
+
+**Explanation:**
+
+![image](image01.png)
+
+**Example 2:**
+
+**Input:** n = 3, commands = ["DOWN","RIGHT","UP"]
+
+**Output:** 1
+
+**Explanation:**
+
+![image](image02.png)
+
+**Constraints:**
+
+*   `2 <= n <= 10`
+*   `1 <= commands.length <= 100`
+*   `commands` consists only of `"UP"`, `"RIGHT"`, `"DOWN"`, and `"LEFT"`.
+*   The input is generated such the snake will not move outside of the boundaries.
+
+## Solution
+
+```java
+import java.util.List;
+
+public class Solution {
+    public int finalPositionOfSnake(int n, List<String> commands) {
+        int x = 0;
+        int y = 0;
+        for (String command : commands) {
+            switch (command) {
+                case "UP":
+                    if (x > 0) {
+                        x--;
+                    }
+                    break;
+                case "DOWN":
+                    if (x < n - 1) {
+                        x++;
+                    }
+                    break;
+                case "LEFT":
+                    if (y > 0) {
+                        y--;
+                    }
+                    break;
+                case "RIGHT":
+                    if (y < n - 1) {
+                        y++;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        return (x * n) + y;
+    }
+}
+```

src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/readme.md

@@ -0,0 +1,133 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3249\. Count the Number of Good Nodes
+
+Medium
+
+There is an **undirected** tree with `n` nodes labeled from `0` to `n - 1`, and rooted at node `0`. You are given a 2D integer array `edges` of length `n - 1`, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.
+
+A node is **good** if all the subtrees rooted at its children have the same size.
+
+Return the number of **good** nodes in the given tree.
+
+A **subtree** of `treeName` is a tree consisting of a node in `treeName` and all of its descendants.
+
+**Example 1:**
+
+**Input:** edges = \[\[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]
+
+**Output:** 7
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/05/26/tree1.png)
+
+All of the nodes of the given tree are good.
+
+**Example 2:**
+
+**Input:** edges = \[\[0,1],[1,2],[2,3],[3,4],[0,5],[1,6],[2,7],[3,8]]
+
+**Output:** 6
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/06/03/screenshot-2024-06-03-193552.png)
+
+There are 6 good nodes in the given tree. They are colored in the image above.
+
+**Example 3:**
+
+**Input:** edges = \[\[0,1],[1,2],[1,3],[1,4],[0,5],[5,6],[6,7],[7,8],[0,9],[9,10],[9,12],[10,11]]
+
+**Output:** 12
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/08/08/rob.jpg)
+
+All nodes except node 9 are good.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   The input is generated such that `edges` represents a valid tree.
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private int count = 0;
+
+    public int countGoodNodes(int[][] edges) {
+        int n = edges.length + 1;
+        TNode[] nodes = new TNode[n];
+        nodes[0] = new TNode(0);
+        for (int[] edge : edges) {
+            int a = edge[0];
+            int b = edge[1];
+            if (nodes[b] != null && nodes[a] == null) {
+                nodes[a] = new TNode(a);
+                nodes[b].children.add(nodes[a]);
+            } else {
+                if (nodes[a] == null) {
+                    nodes[a] = new TNode(a);
+                }
+                if (nodes[b] == null) {
+                    nodes[b] = new TNode(b);
+                }
+                nodes[a].children.add(nodes[b]);
+            }
+        }
+        sizeOfTree(nodes[0]);
+        return count;
+    }
+
+    private int sizeOfTree(TNode node) {
+        if (node.size > 0) {
+            return node.size;
+        }
+        List<TNode> children = node.children;
+        if (children.isEmpty()) {
+            count++;
+            node.size = 1;
+            return 1;
+        }
+        int size = sizeOfTree(children.get(0));
+        int sum = size;
+        boolean goodNode = true;
+        for (int i = 1; i < children.size(); ++i) {
+            TNode child = children.get(i);
+            if (size != sizeOfTree(child)) {
+                goodNode = false;
+            }
+            sum += sizeOfTree(child);
+        }
+        if (goodNode) {
+            count++;
+        }
+        sum++;
+        node.size = sum;
+        return sum;
+    }
+
+    private static class TNode {
+        int val;
+        int size;
+        List<TNode> children;
+
+        TNode(int val) {
+            this.val = val;
+            this.size = -1;
+            this.children = new ArrayList<>();
+        }
+    }
+}
+```

src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/readme.md

@@ -0,0 +1,88 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3250\. Find the Count of Monotonic Pairs I
+
+Hard
+
+You are given an array of **positive** integers `nums` of length `n`.
+
+We call a pair of **non-negative** integer arrays `(arr1, arr2)` **monotonic** if:
+
+*   The lengths of both arrays are `n`.
+*   `arr1` is monotonically **non-decreasing**, in other words, `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`.
+*   `arr2` is monotonically **non-increasing**, in other words, `arr2[0] >= arr2[1] >= ... >= arr2[n - 1]`.
+*   `arr1[i] + arr2[i] == nums[i]` for all `0 <= i <= n - 1`.
+
+Return the count of **monotonic** pairs.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [2,3,2]
+
+**Output:** 4
+
+**Explanation:**
+
+The good pairs are:
+
+1.  `([0, 1, 1], [2, 2, 1])`
+2.  `([0, 1, 2], [2, 2, 0])`
+3.  `([0, 2, 2], [2, 1, 0])`
+4.  `([1, 2, 2], [1, 1, 0])`
+
+**Example 2:**
+
+**Input:** nums = [5,5,5,5]
+
+**Output:** 126
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 2000`
+*   `1 <= nums[i] <= 50`
+
+## Solution
+
+```java
+public class Solution {
+    public int countOfPairs(int[] nums) {
+        int[] maxShift = new int[nums.length];
+        maxShift[0] = nums[0];
+        int currShift = 0;
+        for (int i = 1; i < nums.length; i++) {
+            currShift = Math.max(currShift, nums[i] - maxShift[i - 1]);
+            maxShift[i] = Math.min(maxShift[i - 1], nums[i] - currShift);
+            if (maxShift[i] < 0) {
+                return 0;
+            }
+        }
+        int[][] cases = getAllCases(nums, maxShift);
+        return cases[nums.length - 1][maxShift[nums.length - 1]];
+    }
+
+    private int[][] getAllCases(int[] nums, int[] maxShift) {
+        int[] currCases;
+        int[][] cases = new int[nums.length][];
+        cases[0] = new int[maxShift[0] + 1];
+        for (int i = 0; i < cases[0].length; i++) {
+            cases[0][i] = i + 1;
+        }
+        for (int i = 1; i < nums.length; i++) {
+            currCases = new int[maxShift[i] + 1];
+            currCases[0] = 1;
+            for (int j = 1; j < currCases.length; j++) {
+                int prevCases =
+                        j < cases[i - 1].length
+                                ? cases[i - 1][j]
+                                : cases[i - 1][cases[i - 1].length - 1];
+                currCases[j] = (currCases[j - 1] + prevCases) % (1_000_000_000 + 7);
+            }
+            cases[i] = currCases;
+        }
+        return cases;
+    }
+}
+```