Added tasks 2319, 2320.

Author: javadev

README.md

@@ -1485,6 +1485,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.11'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2320 |[Count Number of Ways to Place Houses](src/main/java/g2301_2400/s2320_count_number_of_ways_to_place_houses/Solution.java)| Medium | Dynamic_Programming | 13 | 82.46
+| 2319 |[Check if Matrix Is X-Matrix](src/main/java/g2301_2400/s2319_check_if_matrix_is_x_matrix/Solution.java)| Easy | Array, Matrix | 3 | 53.58
 | 2318 |[Number of Distinct Roll Sequences](src/main/java/g2301_2400/s2318_number_of_distinct_roll_sequences/Solution.java)| Hard || 254 | 91.67
 | 2317 |[Maximum XOR After Operations](src/main/java/g2301_2400/s2317_maximum_xor_after_operations/Solution.java)| Medium || 1 | 100.00
 | 2316 |[Count Unreachable Pairs of Nodes in an Undirected Graph](src/main/java/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/Solution.java)| Medium || 32 | 100.00

src/main/java/g2301_2400/s2319_check_if_matrix_is_x_matrix/Solution.java

@@ -0,0 +1,22 @@
+package g2301_2400.s2319_check_if_matrix_is_x_matrix;
+
+// #Easy #Array #Matrix #2022_06_28_Time_3_ms_(53.58%)_Space_54_MB_(83.44%)
+
+public class Solution {
+    public boolean checkXMatrix(int[][] grid) {
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (i == j || i + j == grid.length - 1) {
+                    if (grid[i][j] == 0) {
+                        return false;
+                    }
+                } else {
+                    if (grid[i][j] != 0) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2301_2400/s2319_check_if_matrix_is_x_matrix/readme.md

@@ -0,0 +1,44 @@
+2319\. Check if Matrix Is X-Matrix
+
+Easy
+
+A square matrix is said to be an **X-Matrix** if **both** of the following conditions hold:
+
+1.  All the elements in the diagonals of the matrix are **non-zero**.
+2.  All other elements are 0.
+
+Given a 2D integer array `grid` of size `n x n` representing a square matrix, return `true` _if_ `grid` _is an X-Matrix_. Otherwise, return `false`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex1.jpg)
+
+**Input:** grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]
+
+**Output:** true
+
+**Explanation:** Refer to the diagram above.
+
+An X-Matrix should have the green elements (diagonals) be non-zero and the red elements be 0.
+
+Thus, grid is an X-Matrix.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex2.jpg)
+
+**Input:** grid = [[5,7,0],[0,3,1],[0,5,0]]
+
+**Output:** false
+
+**Explanation:** Refer to the diagram above.
+
+An X-Matrix should have the green elements (diagonals) be non-zero and the red elements be 0.
+
+Thus, grid is not an X-Matrix.
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   `3 <= n <= 100`
+*   <code>0 <= grid[i][j] <= 10<sup>5</sup></code>

src/main/java/g2301_2400/s2320_count_number_of_ways_to_place_houses/Solution.java

@@ -0,0 +1,26 @@
+package g2301_2400.s2320_count_number_of_ways_to_place_houses;
+
+// #Medium #Dynamic_Programming #2022_06_28_Time_13_ms_(82.46%)_Space_40.6_MB_(94.91%)
+
+public class Solution {
+    public int countHousePlacements(int n) {
+        // algo - 1st solve one side  of the street
+        // think 0 - space , 1 - house
+        // if n = 1 then we can take one 0 and one 1 (total ways = 2)
+        // if n = 2 then 00 , 01 , 10 , 11 but we cant take 11 as two house cant be adjacent.
+        // so the 1 ended string will be only 1 which is same as previous 0 ended string and 0 ended
+        // string are 2 which is previous sum(total ways)
+        // apply this formula for n no's
+        long mod = 1000000007;
+        long space = 1;
+        long house = 1;
+        long sum = space + house;
+        while (--n > 0) {
+            house = space;
+            space = sum;
+            sum = (house + space) % mod;
+        }
+        // as street has two side
+        return (int) ((sum * sum) % mod);
+    }
+}

src/main/java/g2301_2400/s2320_count_number_of_ways_to_place_houses/readme.md

@@ -0,0 +1,41 @@
+2320\. Count Number of Ways to Place Houses
+
+Medium
+
+There is a street with `n * 2` **plots**, where there are `n` plots on each side of the street. The plots on each side are numbered from `1` to `n`. On each plot, a house can be placed.
+
+Return _the number of ways houses can be placed such that no two houses are adjacent to each other on the same side of the street_. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Note that if a house is placed on the <code>i<sup>th</sup></code> plot on one side of the street, a house can also be placed on the <code>i<sup>th</sup></code> plot on the other side of the street.
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** 4
+
+**Explanation:**
+
+Possible arrangements:
+
+1. All plots are empty.
+
+2. A house is placed on one side of the street.
+
+3. A house is placed on the other side of the street.
+
+4. Two houses are placed, one on each side of the street.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/12/arrangements.png)
+
+**Input:** n = 2
+
+**Output:** 9
+
+**Explanation:** The 9 possible arrangements are shown in the diagram above.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>

src/test/java/g2301_2400/s2319_check_if_matrix_is_x_matrix/SolutionTest.java

@@ -0,0 +1,41 @@
+package g2301_2400.s2319_check_if_matrix_is_x_matrix;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void checkXMatrix() {
+        assertThat(
+                new Solution()
+                        .checkXMatrix(
+                                new int[][] {
+                                    {2, 0, 0, 1}, {0, 3, 1, 0}, {0, 5, 2, 0}, {4, 0, 0, 2}
+                                }),
+                equalTo(true));
+    }
+
+    @Test
+    void checkXMatrix2() {
+        assertThat(
+                new Solution().checkXMatrix(new int[][] {{5, 7, 0}, {0, 3, 1}, {0, 5, 0}}),
+                equalTo(false));
+    }
+
+    @Test
+    void checkXMatrix3() {
+        assertThat(
+                new Solution()
+                        .checkXMatrix(
+                                new int[][] {
+                                    {0, 0, 0, 0, 1},
+                                    {0, 4, 0, 1, 0},
+                                    {0, 0, 5, 0, 0},
+                                    {0, 5, 0, 2, 0},
+                                    {4, 0, 0, 0, 2}
+                                }),
+                equalTo(false));
+    }
+}

src/test/java/g2301_2400/s2320_count_number_of_ways_to_place_houses/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2320_count_number_of_ways_to_place_houses;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countHousePlacements() {
+        assertThat(new Solution().countHousePlacements(1), equalTo(4));
+    }
+
+    @Test
+    void countHousePlacements2() {
+        assertThat(new Solution().countHousePlacements(2), equalTo(9));
+    }
+}