Added tasks 2086, 2087, 2088.

Author: javadev

src/main/java/g2001_2100/s2086_minimum_number_of_buckets_required_to_collect_rainwater_from_houses/Solution.java

@@ -0,0 +1,43 @@
+package g2001_2100.s2086_minimum_number_of_buckets_required_to_collect_rainwater_from_houses;
+
+// #Medium #String #Dynamic_Programming #Greedy
+// #2022_05_27_Time_8_ms_(73.71%)_Space_50.4_MB_(40.57%)
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int minimumBuckets(String street) {
+        // check if houses have space in between or not
+        // eg:".HHH."
+        // array formation
+        char[] arr = street.toCharArray();
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] == '.') {
+                continue;
+            }
+            if (i + 1 < arr.length && arr[i + 1] == '.') {
+                continue;
+            }
+            // H is present before curr character
+            if (i - 1 >= 0 && arr[i - 1] == '.') {
+                continue;
+            }
+            return -1;
+        }
+        int x = 0;
+        for (int j = 0; j < arr.length; j++) {
+            // point move next we only take care of H
+            if (arr[j] == 'H') {
+                if (j - 1 >= 0 && arr[j - 1] == 'X') {
+                    continue;
+                }
+                if (j + 1 < arr.length && arr[j + 1] == '.') {
+                    arr[j + 1] = 'X';
+                } else {
+                    arr[j - 1] = 'X';
+                }
+                x++;
+            }
+        }
+        return x;
+    }
+}

src/main/java/g2001_2100/s2086_minimum_number_of_buckets_required_to_collect_rainwater_from_houses/readme.md

@@ -0,0 +1,58 @@
+2086\. Minimum Number of Buckets Required to Collect Rainwater from Houses
+
+Medium
+
+You are given a **0-index****ed** string `street`. Each character in `street` is either `'H'` representing a house or `'.'` representing an empty space.
+
+You can place buckets on the **empty spaces** to collect rainwater that falls from the adjacent houses. The rainwater from a house at index `i` is collected if a bucket is placed at index `i - 1` **and/or** index `i + 1`. A single bucket, if placed adjacent to two houses, can collect the rainwater from **both** houses.
+
+Return _the **minimum** number of buckets needed so that for **every** house, there is **at least** one bucket collecting rainwater from it, or_ `-1` _if it is impossible._
+
+**Example 1:**
+
+**Input:** street = "H..H"
+
+**Output:** 2
+
+**Explanation:**
+
+We can put buckets at index 1 and index 2.
+
+"H..H" -> "HBBH" ('B' denotes where a bucket is placed).
+
+The house at index 0 has a bucket to its right, and the house at index 3 has a bucket to its left.
+
+Thus, for every house, there is at least one bucket collecting rainwater from it. 
+
+**Example 2:**
+
+**Input:** street = ".H.H."
+
+**Output:** 1
+
+**Explanation:**
+
+We can put a bucket at index 2.
+
+".H.H." -> ".HBH." ('B' denotes where a bucket is placed).
+
+The house at index 1 has a bucket to its right, and the house at index 3 has a bucket to its left.
+
+Thus, for every house, there is at least one bucket collecting rainwater from it. 
+
+**Example 3:**
+
+**Input:** street = ".HHH."
+
+**Output:** -1
+
+**Explanation:**
+
+There is no empty space to place a bucket to collect the rainwater from the house at index 2.
+
+Thus, it is impossible to collect the rainwater from all the houses. 
+
+**Constraints:**
+
+*   <code>1 <= street.length <= 10<sup>5</sup></code>
+*   `street[i]` is either`'H'` or `'.'`.

src/main/java/g2001_2100/s2087_minimum_cost_homecoming_of_a_robot_in_a_grid/Solution.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2087_minimum_cost_homecoming_of_a_robot_in_a_grid;
+
+// #Medium #Array #Greedy #Matrix #2022_05_27_Time_2_ms_(79.89%)_Space_61.9_MB_(83.07%)
+
+public class Solution {
+    public int minCost(int[] startPos, int[] homePos, int[] rowCosts, int[] colCosts) {
+        int cost = 0;
+        for (int i = Math.min(startPos[0], homePos[0]);
+                i <= Math.max(startPos[0], homePos[0]);
+                i++) {
+            cost += rowCosts[i];
+        }
+        for (int j = Math.min(startPos[1], homePos[1]);
+                j <= Math.max(startPos[1], homePos[1]);
+                j++) {
+            cost += colCosts[j];
+        }
+        return cost - rowCosts[startPos[0]] - colCosts[startPos[1]];
+    }
+}

src/main/java/g2001_2100/s2087_minimum_cost_homecoming_of_a_robot_in_a_grid/readme.md

@@ -0,0 +1,53 @@
+2087\. Minimum Cost Homecoming of a Robot in a Grid
+
+Medium
+
+There is an `m x n` grid, where `(0, 0)` is the top-left cell and `(m - 1, n - 1)` is the bottom-right cell. You are given an integer array `startPos` where <code>startPos = [start<sub>row</sub>, start<sub>col</sub>]</code> indicates that **initially**, a **robot** is at the cell <code>(start<sub>row</sub>, start<sub>col</sub>)</code>. You are also given an integer array `homePos` where <code>homePos = [home<sub>row</sub>, home<sub>col</sub>]</code> indicates that its **home** is at the cell <code>(home<sub>row</sub>, home<sub>col</sub>)</code>.
+
+The robot needs to go to its home. It can move one cell in four directions: **left**, **right**, **up**, or **down**, and it can not move outside the boundary. Every move incurs some cost. You are further given two **0-indexed** integer arrays: `rowCosts` of length `m` and `colCosts` of length `n`.
+
+*   If the robot moves **up** or **down** into a cell whose **row** is `r`, then this move costs `rowCosts[r]`.
+*   If the robot moves **left** or **right** into a cell whose **column** is `c`, then this move costs `colCosts[c]`.
+
+Return _the **minimum total cost** for this robot to return home_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/10/11/eg-1.png)
+
+**Input:** startPos = [1, 0], homePos = [2, 3], rowCosts = [5, 4, 3], colCosts = [8, 2, 6, 7]
+
+**Output:** 18
+
+**Explanation:** One optimal path is that:
+
+Starting from (1, 0)
+
+-> It goes down to (**2**, 0). This move costs rowCosts[2] = 3.
+
+-> It goes right to (2, **1**). This move costs colCosts[1] = 2.
+
+-> It goes right to (2, **2**). This move costs colCosts[2] = 6.
+
+-> It goes right to (2, **3**). This move costs colCosts[3] = 7.
+
+The total cost is 3 + 2 + 6 + 7 = 18
+
+**Example 2:**
+
+**Input:** startPos = [0, 0], homePos = [0, 0], rowCosts = [5], colCosts = [26]
+
+**Output:** 0
+
+**Explanation:** The robot is already at its home. Since no moves occur, the total cost is 0.
+
+**Constraints:**
+
+*   `m == rowCosts.length`
+*   `n == colCosts.length`
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>0 <= rowCosts[r], colCosts[c] <= 10<sup>4</sup></code>
+*   `startPos.length == 2`
+*   `homePos.length == 2`
+*   <code>0 <= start<sub>row</sub>, home<sub>row</sub> < m</code>
+*   <code>0 <= start<sub>col</sub>, home<sub>col</sub> < n</code>

src/main/java/g2001_2100/s2088_count_fertile_pyramids_in_a_land/Solution.java

@@ -0,0 +1,37 @@
+package g2001_2100.s2088_count_fertile_pyramids_in_a_land;
+
+// #Hard #Array #Dynamic_Programming #Matrix #2022_05_27_Time_12_ms_(83.56%)_Space_75.5_MB_(41.09%)
+
+public class Solution {
+    public int countPyramids(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] rev = new int[m][n];
+        for (int i = 0; i < m; ++i) {
+            System.arraycopy(grid[i], 0, rev[m - i - 1], 0, n);
+        }
+        return cal(grid) + cal(rev);
+    }
+
+    private int cal(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int res = 0;
+        for (int i = 1; i < m; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (0 != grid[i][j]) {
+                    cnt++;
+                } else {
+                    cnt = 0;
+                }
+                if (0 == cnt || 0 == j) {
+                    continue;
+                }
+                grid[i][j] = Math.min(grid[i - 1][j - 1] + 1, (cnt + 1) >> 1);
+                res += grid[i][j] - 1;
+            }
+        }
+        return res;
+    }
+}

src/main/java/g2001_2100/s2088_count_fertile_pyramids_in_a_land/readme.md

@@ -0,0 +1,69 @@
+2088\. Count Fertile Pyramids in a Land
+
+Hard
+
+A farmer has a **rectangular grid** of land with `m` rows and `n` columns that can be divided into unit cells. Each cell is either **fertile** (represented by a `1`) or **barren** (represented by a `0`). All cells outside the grid are considered barren.
+
+A **pyramidal plot** of land can be defined as a set of cells with the following criteria:
+
+1.  The number of cells in the set has to be **greater than** `1` and all cells must be **fertile**.
+2.  The **apex** of a pyramid is the **topmost** cell of the pyramid. The **height** of a pyramid is the number of rows it covers. Let `(r, c)` be the apex of the pyramid, and its height be `h`. Then, the plot comprises of cells `(i, j)` where `r <= i <= r + h - 1` **and** `c - (i - r) <= j <= c + (i - r)`.
+
+An **inverse pyramidal plot** of land can be defined as a set of cells with similar criteria:
+
+1.  The number of cells in the set has to be **greater than** `1` and all cells must be **fertile**.
+2.  The **apex** of an inverse pyramid is the **bottommost** cell of the inverse pyramid. The **height** of an inverse pyramid is the number of rows it covers. Let `(r, c)` be the apex of the pyramid, and its height be `h`. Then, the plot comprises of cells `(i, j)` where `r - h + 1 <= i <= r` **and** `c - (r - i) <= j <= c + (r - i)`.
+
+Some examples of valid and invalid pyramidal (and inverse pyramidal) plots are shown below. Black cells indicate fertile cells.
+
+![](https://assets.leetcode.com/uploads/2021/11/08/image.png)
+
+Given a **0-indexed** `m x n` binary matrix `grid` representing the farmland, return _the **total number** of pyramidal and inverse pyramidal plots that can be found in_ `grid`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/12/22/1.JPG)
+
+**Input:** grid = [[0,1,1,0],[1,1,1,1]]
+
+**Output:** 2
+
+**Explanation:** The 2 possible pyramidal plots are shown in blue and red respectively.
+
+There are no inverse pyramidal plots in this grid.
+
+Hence total number of pyramidal and inverse pyramidal plots is 2 + 0 = 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/12/22/2.JPG)
+
+**Input:** grid = [[1,1,1],[1,1,1]]
+
+**Output:** 2
+
+**Explanation:** The pyramidal plot is shown in blue, and the inverse pyramidal plot is shown in red.
+
+Hence the total number of plots is 1 + 1 = 2.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/12/22/3.JPG)
+
+**Input:** grid = [[1,1,1,1,0],[1,1,1,1,1],[1,1,1,1,1],[0,1,0,0,1]]
+
+**Output:** 13
+
+**Explanation:** There are 7 pyramidal plots, 3 of which are shown in the 2nd and 3rd figures.
+
+There are 6 inverse pyramidal plots, 2 of which are shown in the last figure.
+
+The total number of plots is 7 + 6 = 13.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 1000`
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `grid[i][j]` is either `0` or `1`.

src/test/java/g2001_2100/s2086_minimum_number_of_buckets_required_to_collect_rainwater_from_houses/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2086_minimum_number_of_buckets_required_to_collect_rainwater_from_houses;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumBuckets() {
+        assertThat(new Solution().minimumBuckets("H..H"), equalTo(2));
+    }
+
+    @Test
+    void minimumBuckets2() {
+        assertThat(new Solution().minimumBuckets(".H.H."), equalTo(1));
+    }
+
+    @Test
+    void minimumBuckets3() {
+        assertThat(new Solution().minimumBuckets(".HHH."), equalTo(-1));
+    }
+}

src/test/java/g2001_2100/s2087_minimum_cost_homecoming_of_a_robot_in_a_grid/SolutionTest.java

@@ -0,0 +1,28 @@
+package g2001_2100.s2087_minimum_cost_homecoming_of_a_robot_in_a_grid;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minCost() {
+        assertThat(
+                new Solution()
+                        .minCost(
+                                new int[] {1, 0},
+                                new int[] {2, 3},
+                                new int[] {5, 4, 3},
+                                new int[] {8, 2, 6, 7}),
+                equalTo(18));
+    }
+
+    @Test
+    void minCost2() {
+        assertThat(
+                new Solution()
+                        .minCost(new int[] {0, 0}, new int[] {0, 0}, new int[] {5}, new int[] {26}),
+                equalTo(0));
+    }
+}

src/test/java/g2001_2100/s2088_count_fertile_pyramids_in_a_land/SolutionTest.java

@@ -0,0 +1,33 @@
+package g2001_2100.s2088_count_fertile_pyramids_in_a_land;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countPyramids() {
+        assertThat(
+                new Solution().countPyramids(new int[][] {{0, 1, 1, 0}, {1, 1, 1, 1}}), equalTo(2));
+    }
+
+    @Test
+    void countPyramids2() {
+        assertThat(new Solution().countPyramids(new int[][] {{1, 1, 1}, {1, 1, 1}}), equalTo(2));
+    }
+
+    @Test
+    void countPyramids3() {
+        assertThat(
+                new Solution()
+                        .countPyramids(
+                                new int[][] {
+                                    {1, 1, 1, 1, 0},
+                                    {1, 1, 1, 1, 1},
+                                    {1, 1, 1, 1, 1},
+                                    {0, 1, 0, 0, 1}
+                                }),
+                equalTo(13));
+    }
+}