Added tasks 2477, 2478, 2481, 2482, 2483

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.17'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2483 |[Minimum Penalty for a Shop](src/main/java/g2401_2500/s2483_minimum_penalty_for_a_shop/Solution.java)| Medium | String, Prefix_Sum | 17 | 69.62
+| 2482 |[Difference Between Ones and Zeros in Row and Column](src/main/java/g2401_2500/s2482_difference_between_ones_and_zeros_in_row_and_column/Solution.java)| Medium | Array, Matrix, Simulation | 9 | 94.05
+| 2481 |[Minimum Cuts to Divide a Circle](src/main/java/g2401_2500/s2481_minimum_cuts_to_divide_a_circle/Solution.java)| Easy | Math, Geometry | 0 | 100.00
+| 2478 |[Number of Beautiful Partitions](src/main/java/g2401_2500/s2478_number_of_beautiful_partitions/Solution.java)| Hard | String, Dynamic_Programming | 44 | 90.08
+| 2477 |[Minimum Fuel Cost to Report to the Capital](src/main/java/g2401_2500/s2477_minimum_fuel_cost_to_report_to_the_capital/Solution.java)| Medium | Tree, Graph, Breadth_First_Search, Depth_First_Search | 70 | 72.49
 | 2476 |[Closest Nodes Queries in a Binary Search Tree](src/main/java/g2401_2500/s2476_closest_nodes_queries_in_a_binary_search_tree/Solution.java)| Medium | Array, Tree, Binary_Search, Binary_Tree, Depth_First_Search | 185 | 51.92
 | 2475 |[Number of Unequal Triplets in Array](src/main/java/g2401_2500/s2475_number_of_unequal_triplets_in_array/Solution.java)| Easy | Array, Hash_Table | 1 | 97.49
 | 2472 |[Maximum Number of Non-overlapping Palindrome Substrings](src/main/java/g2401_2500/s2472_maximum_number_of_non_overlapping_palindrome_substrings/Solution.java)| Hard | String, Dynamic_Programming | 2 | 91.04

src/main/java/g2401_2500/s2477_minimum_fuel_cost_to_report_to_the_capital/Solution.java

@@ -0,0 +1,38 @@
+package g2401_2500.s2477_minimum_fuel_cost_to_report_to_the_capital;
+
+// #Medium #Tree #Graph #Breadth_First_Search #Depth_First_Search
+// #2023_01_25_Time_70_ms_(72.49%)_Space_102.5_MB_(74.76%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    private long ans = 0L;
+
+    public long minimumFuelCost(int[][] roads, int seats) {
+        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+        int n = roads.length + 1;
+        ans = 0L;
+        for (int i = 0; i < n; i++) {
+            adj.add(new ArrayList<>());
+        }
+        for (int[] a : roads) {
+            adj.get(a[0]).add(a[1]);
+            adj.get(a[1]).add(a[0]);
+        }
+        solve(adj, seats, 0, -1);
+        return ans;
+    }
+
+    private long solve(ArrayList<ArrayList<Integer>> adj, int seats, int src, int parent) {
+        int people = 1;
+        for (int i : adj.get(src)) {
+            if (i != parent) {
+                people += solve(adj, seats, i, src);
+            }
+        }
+        if (src != 0) {
+            ans += (long) Math.ceil((double) people / seats);
+        }
+        return people;
+    }
+}

src/main/java/g2401_2500/s2477_minimum_fuel_cost_to_report_to_the_capital/readme.md

@@ -0,0 +1,68 @@
+2477\. Minimum Fuel Cost to Report to the Capital
+
+Medium
+
+There is a tree (i.e., a connected, undirected graph with no cycles) structure country network consisting of `n` cities numbered from `0` to `n - 1` and exactly `n - 1` roads. The capital city is city `0`. You are given a 2D integer array `roads` where <code>roads[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists a **bidirectional road** connecting cities <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.
+
+There is a meeting for the representatives of each city. The meeting is in the capital city.
+
+There is a car in each city. You are given an integer `seats` that indicates the number of seats in each car.
+
+A representative can use the car in their city to travel or change the car and ride with another representative. The cost of traveling between two cities is one liter of fuel.
+
+Return _the minimum number of liters of fuel to reach the capital city_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/09/22/a4c380025e3ff0c379525e96a7d63a3.png)
+
+**Input:** roads = [[0,1],[0,2],[0,3]], seats = 5
+
+**Output:** 3
+
+**Explanation:**
+- Representative<sub>1</sub> goes directly to the capital with 1 liter of fuel. 
+- Representative<sub>2</sub> goes directly to the capital with 1 liter of fuel. 
+- Representative<sub>3</sub> goes directly to the capital with 1 liter of fuel. 
+
+It costs 3 liters of fuel at minimum. It can be proven that 3 is the minimum number of liters of fuel needed.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/16/2.png)
+
+**Input:** roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
+
+**Output:** 7
+
+**Explanation:**
+- Representative<sub>2</sub> goes directly to city 3 with 1 liter of fuel.
+- Representative<sub>2</sub> and representative<sub>3</sub> go together to city 1 with 1 liter of fuel. 
+- Representative<sub>2</sub> and representative<sub>3</sub> go together to the capital with 1 liter of fuel. 
+- Representative<sub>1</sub> goes directly to the capital with 1 liter of fuel. 
+- Representative<sub>5</sub> goes directly to the capital with 1 liter of fuel. 
+- Representative<sub>6</sub> goes directly to city 4 with 1 liter of fuel. 
+- Representative<sub>4</sub> and representative<sub>6</sub> go together to the capital with 1 liter of fuel. 
+
+It costs 7 liters of fuel at minimum. 
+It can be proven that 7 is the minimum number of liters of fuel needed.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2022/09/27/efcf7f7be6830b8763639cfd01b690a.png)
+
+**Input:** roads = [], seats = 1
+
+**Output:** 0
+
+**Explanation:** No representatives need to travel to the capital city.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `roads.length == n - 1`
+*   `roads[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   `roads` represents a valid tree.
+*   <code>1 <= seats <= 10<sup>5</sup></code>

src/main/java/g2401_2500/s2478_number_of_beautiful_partitions/Solution.java

@@ -0,0 +1,48 @@
+package g2401_2500.s2478_number_of_beautiful_partitions;
+
+// #Hard #String #Dynamic_Programming #2023_01_25_Time_44_ms_(90.08%)_Space_55.1_MB_(32.23%)
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int beautifulPartitions(String s, int k, int l) {
+        char[] cs = s.toCharArray();
+        int n = cs.length;
+        if (!prime(cs[0]) || prime(cs[n - 1])) {
+            return 0;
+        }
+        int[][] dp = new int[k][n];
+        for (int i = n - l; 0 <= i; --i) {
+            dp[0][i] = prime(cs[i]) ? 1 : 0;
+        }
+        for (int i = 1; i < k; ++i) {
+            int sum = 0;
+            for (int j = n - i * l; 0 <= j; --j) {
+                int mod = (int) 1e9 + 7;
+                if (0 == dp[i - 1][j]) {
+                    dp[i - 1][j] = sum;
+                } else if (0 != j && 0 == dp[i - 1][j - 1]) {
+                    sum = (sum + dp[i - 1][j]) % mod;
+                }
+            }
+            int p = l - 1;
+            for (int j = 0; j + l * i < n; ++j) {
+                if (!prime(cs[j])) {
+                    continue;
+                }
+                p = Math.max(p, j + l - 1);
+                while (prime(cs[p])) {
+                    p++;
+                }
+                if (0 == dp[i - 1][p]) {
+                    break;
+                }
+                dp[i][j] = dp[i - 1][p];
+            }
+        }
+        return dp[k - 1][0];
+    }
+
+    private boolean prime(char c) {
+        return '2' == c || '3' == c || '5' == c || '7' == c;
+    }
+}

src/main/java/g2401_2500/s2478_number_of_beautiful_partitions/readme.md

@@ -0,0 +1,50 @@
+2478\. Number of Beautiful Partitions
+
+Hard
+
+You are given a string `s` that consists of the digits `'1'` to `'9'` and two integers `k` and `minLength`.
+
+A partition of `s` is called **beautiful** if:
+
+*   `s` is partitioned into `k` non-intersecting substrings.
+*   Each substring has a length of **at least** `minLength`.
+*   Each substring starts with a **prime** digit and ends with a **non-prime** digit. Prime digits are `'2'`, `'3'`, `'5'`, and `'7'`, and the rest of the digits are non-prime.
+
+Return _the number of **beautiful** partitions of_ `s`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "23542185131", k = 3, minLength = 2
+
+**Output:** 3
+
+**Explanation:** There exists three ways to create a beautiful partition: 
+
+"2354 | 218 | 5131" 
+
+"2354 | 21851 | 31" 
+
+"2354218 | 51 | 31"
+
+**Example 2:**
+
+**Input:** s = "23542185131", k = 3, minLength = 3
+
+**Output:** 1
+
+**Explanation:** There exists one way to create a beautiful partition: "2354 | 218 | 5131".
+
+**Example 3:**
+
+**Input:** s = "3312958", k = 3, minLength = 1
+
+**Output:** 1
+
+**Explanation:** There exists one way to create a beautiful partition: "331 | 29 | 58".
+
+**Constraints:**
+
+*   `1 <= k, minLength <= s.length <= 1000`
+*   `s` consists of the digits `'1'` to `'9'`.

src/main/java/g2401_2500/s2481_minimum_cuts_to_divide_a_circle/Solution.java

@@ -0,0 +1,12 @@
+package g2401_2500.s2481_minimum_cuts_to_divide_a_circle;
+
+// #Easy #Math #Geometry #2023_01_25_Time_0_ms_(100.00%)_Space_39.2_MB_(87.50%)
+
+public class Solution {
+    public int numberOfCuts(int n) {
+        if (n == 1) {
+            return 0;
+        }
+        return n % 2 > 0 ? n : n / 2;
+    }
+}

src/main/java/g2401_2500/s2481_minimum_cuts_to_divide_a_circle/readme.md

@@ -0,0 +1,44 @@
+2481\. Minimum Cuts to Divide a Circle
+
+Easy
+
+A **valid cut** in a circle can be:
+
+*   A cut that is represented by a straight line that touches two points on the edge of the circle and passes through its center, or
+*   A cut that is represented by a straight line that touches one point on the edge of the circle and its center.
+
+Some valid and invalid cuts are shown in the figures below.
+
+![](https://assets.leetcode.com/uploads/2022/10/29/alldrawio.png)
+
+Given the integer `n`, return _the **minimum** number of cuts needed to divide a circle into_ `n` _equal slices_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/24/11drawio.png)
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Explanation:** The above figure shows how cutting the circle twice through the middle divides it into 4 equal slices.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/10/24/22drawio.png)
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** 
+
+At least 3 cuts are needed to divide the circle into 3 equal slices. 
+
+It can be shown that less than 3 cuts cannot result in 3 slices of equal size and shape. 
+
+Also note that the first cut will not divide the circle into distinct parts.
+
+**Constraints:**
+
+*   `1 <= n <= 100`

src/main/java/g2401_2500/s2482_difference_between_ones_and_zeros_in_row_and_column/Solution.java

@@ -0,0 +1,36 @@
+package g2401_2500.s2482_difference_between_ones_and_zeros_in_row_and_column;
+
+// #Medium #Array #Matrix #Simulation #2023_01_25_Time_9_ms_(94.05%)_Space_76.3_MB_(95.36%)
+
+public class Solution {
+    public int[][] onesMinusZeros(int[][] grid) {
+        int[] rowOne = new int[grid.length];
+        int[] colOne = new int[grid[0].length];
+        int m = grid.length;
+        int n = grid[0].length;
+        for (int i = 0; i < m; i++) {
+            int c = 0;
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    c++;
+                }
+            }
+            rowOne[i] = c;
+        }
+        for (int i = 0; i < n; i++) {
+            int c = 0;
+            for (int[] ints : grid) {
+                if (ints[i] == 1) {
+                    c++;
+                }
+            }
+            colOne[i] = c;
+        }
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                grid[i][j] = rowOne[i] + colOne[j] - (m - rowOne[i]) - (n - colOne[j]);
+            }
+        }
+        return grid;
+    }
+}

src/main/java/g2401_2500/s2482_difference_between_ones_and_zeros_in_row_and_column/readme.md

@@ -0,0 +1,58 @@
+2482\. Difference Between Ones and Zeros in Row and Column
+
+Medium
+
+You are given a **0-indexed** `m x n` binary matrix `grid`.
+
+A **0-indexed** `m x n` difference matrix `diff` is created with the following procedure:
+
+*   Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.
+*   Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.
+*   Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.
+*   Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.
+*   <code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code>
+
+Return _the difference matrix_ `diff`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png)
+
+**Input:** grid = [[0,1,1],[1,0,1],[0,0,1]]
+
+**Output:** [[0,0,4],[0,0,4],[-2,-2,2]]
+
+**Explanation:**
+- diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 
+- diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 
+- diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 
+- diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 
+- diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png)
+
+**Input:** grid = [[1,1,1],[1,1,1]]
+
+**Output:** [[5,5,5],[5,5,5]]
+
+**Explanation:** 
+- diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 
+- diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 
+- diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 
+- diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 
+- diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 
+- diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `grid[i][j]` is either `0` or `1`.