add 1605

Author: fishercoder1534

Diff for: paginated_contents/algorithms/2nd_thousand/README.md

@@ -171,6 +171,7 @@
 | 1614 | [Maximum Nesting Depth of the Parentheses](https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/)                                                                          | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1614.java)                                                                                       || Easy                                                | String                           |
 | 1609 | [Even Odd Tree](https://leetcode.com/problems/even-odd-tree/)                                                                                                                                | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1609.java)                                                                                       || Medium                                              | Tree                             |
 | 1608 | [Special Array With X Elements Greater Than or Equal X](https://leetcode.com/problems/special-array-with-x-elements-greater-than-or-equal-x/)                                                | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1608.java)                                                                                       || Easy                                                | Array                            |
+| 1605 | [Find Valid Matrix Given Row and Column Sums](https://leetcode.com/problems/find-valid-matrix-given-row-and-column-sums/)                      | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1605.java)                                                                                       || Medium                                              | Greedy, Array, Matrix            |
 | 1604 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://leetcode.com/problems/alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/)                      | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1604.java)                                                                                       || Medium                                              | String, Ordered Map              |
 | 1603 | [Design Parking System](https://leetcode.com/problems/design-parking-system/)                                                                                                                | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1603.java)                                                                                       || Easy                                                | Design                           |
 | 1602 | [Find Nearest Right Node in Binary Tree](https://leetcode.com/problems/find-nearest-right-node-in-binary-tree/)                                                                                                                | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1602.java)                                                                                       || Medium                                              | Tree, BFS                        |

Diff for: src/main/java/com/fishercoder/solutions/secondthousand/_1605.java

@@ -0,0 +1,42 @@
+package com.fishercoder.solutions.secondthousand;
+
+import java.util.PriorityQueue;
+
+public class _1605 {
+    public static class Solution1 {
+        /**
+         * My completely original solution:
+         * 1. sort out your logic with a pen and paper first, greedy algorithm should be the way to go;
+         * 2. each time, take out the minimum value from both rowSet and colSet, put that entire value onto the result grid,
+         * then deduct that value from the other set if they are not equal, put it back into the minHeap, repeat until both minHeaps are empty;
+         */
+        public int[][] restoreMatrix(int[] rowSum, int[] colSum) {
+            //form two minHeaps, use their values to sort
+            PriorityQueue<int[]> rowMinHeap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+            for (int i = 0; i < rowSum.length; i++) {
+                rowMinHeap.offer(new int[]{i, rowSum[i]});
+            }
+            PriorityQueue<int[]> colMinHeap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+            for (int j = 0; j < colSum.length; j++) {
+                colMinHeap.offer(new int[]{j, colSum[j]});
+            }
+
+            int[][] result = new int[rowSum.length][colSum.length];
+            while (!colMinHeap.isEmpty() && !rowMinHeap.isEmpty()) {
+                int[] minRow = rowMinHeap.poll();
+                int[] minCol = colMinHeap.poll();
+                if (minRow[1] < minCol[1]) {
+                    result[minRow[0]][minCol[0]] = minRow[1];
+                    colMinHeap.offer(new int[]{minCol[0], minCol[1] - minRow[1]});
+                } else if (minRow[1] > minCol[1]) {
+                    result[minRow[0]][minCol[0]] = minCol[1];
+                    rowMinHeap.offer(new int[]{minRow[0], minRow[1] - minCol[1]});
+                } else {
+                    //the min values from row and col are equal
+                    result[minRow[0]][minCol[0]] = minCol[1];
+                }
+            }
+            return result;
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/secondthousand/_1605Test.java

@@ -0,0 +1,25 @@
+package com.fishercoder.secondthousand;
+
+import com.fishercoder.solutions.secondthousand._1605;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class _1605Test {
+    private static _1605.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _1605.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        int[][] expected = new int[][]{
+                {0, 5, 0}, {0, 1, 6}, {8, 0, 2}
+        };
+        assertArrayEquals(expected, solution1.restoreMatrix(new int[]{5, 7, 10}, new int[]{8, 6, 8}));
+    }
+
+}