feat: solve No.1605,2392

Author: BaffinLee

1601-1700/1605. Find Valid Matrix Given Row and Column Sums.md

@@ -0,0 +1,88 @@
+# 1605. Find Valid Matrix Given Row and Column Sums
+
+- Difficulty: Medium.
+- Related Topics: Array, Greedy, Matrix.
+- Similar Questions: Reconstruct a 2-Row Binary Matrix.
+
+## Problem
+
+You are given two arrays `rowSum` and `colSum` of non-negative integers where `rowSum[i]` is the sum of the elements in the `ith` row and `colSum[j]` is the sum of the elements of the `jth` column of a 2D matrix. In other words, you do not know the elements of the matrix, but you do know the sums of each row and column.
+
+Find any matrix of **non-negative** integers of size `rowSum.length x colSum.length` that satisfies the `rowSum` and `colSum` requirements.
+
+Return **a 2D array representing **any** matrix that fulfills the requirements**. It's guaranteed that **at least one **matrix that fulfills the requirements exists.
+
+ 
+Example 1:
+
+```
+Input: rowSum = [3,8], colSum = [4,7]
+Output: [[3,0],
+         [1,7]]
+Explanation: 
+0th row: 3 + 0 = 3 == rowSum[0]
+1st row: 1 + 7 = 8 == rowSum[1]
+0th column: 3 + 1 = 4 == colSum[0]
+1st column: 0 + 7 = 7 == colSum[1]
+The row and column sums match, and all matrix elements are non-negative.
+Another possible matrix is: [[1,2],
+                             [3,5]]
+```
+
+Example 2:
+
+```
+Input: rowSum = [5,7,10], colSum = [8,6,8]
+Output: [[0,5,0],
+         [6,1,0],
+         [2,0,8]]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= rowSum.length, colSum.length <= 500`
+	
+- `0 <= rowSum[i], colSum[i] <= 108`
+	
+- `sum(rowSum) == sum(colSum)`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} rowSum
+ * @param {number[]} colSum
+ * @return {number[][]}
+ */
+var restoreMatrix = function(rowSum, colSum) {
+    var m = rowSum.length;
+    var n = colSum.length;
+    var res = Array(m).fill(0).map(() => Array(n).fill(0));
+    for (var i = 0; i < m; i++) {
+        res[i][0] = rowSum[i];
+    }
+    for (var i = 0; i < n - 1; i++) {
+        for (var j = 0; j < m; j++) {
+            var num = Math.min(res[j][i], colSum[i]);
+            res[j][i + 1] = res[j][i] - num;
+            res[j][i] = num;
+            colSum[i] -= num;
+        }
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * m).
+* Space complexity : O(n * m).

2301-2400/2392. Build a Matrix With Conditions.md

@@ -0,0 +1,138 @@
+# 2392. Build a Matrix With Conditions
+
+- Difficulty: Hard.
+- Related Topics: Array, Graph, Topological Sort, Matrix.
+- Similar Questions: Course Schedule, Course Schedule II, Find Eventual Safe States, Loud and Rich.
+
+## Problem
+
+You are given a **positive** integer `k`. You are also given:
+
+
+	
+- a 2D integer array `rowConditions` of size `n` where `rowConditions[i] = [abovei, belowi]`, and
+	
+- a 2D integer array `colConditions` of size `m` where `colConditions[i] = [lefti, righti]`.
+
+
+The two arrays contain integers from `1` to `k`.
+
+You have to build a `k x k` matrix that contains each of the numbers from `1` to `k` **exactly once**. The remaining cells should have the value `0`.
+
+The matrix should also satisfy the following conditions:
+
+
+	
+- The number `abovei` should appear in a **row** that is strictly **above** the row at which the number `belowi` appears for all `i` from `0` to `n - 1`.
+	
+- The number `lefti` should appear in a **column** that is strictly **left** of the column at which the number `righti` appears for all `i` from `0` to `m - 1`.
+
+
+Return ****any** matrix that satisfies the conditions**. If no answer exists, return an empty matrix.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2022/07/06/gridosdrawio.png)
+
+```
+Input: k = 3, rowConditions = [[1,2],[3,2]], colConditions = [[2,1],[3,2]]
+Output: [[3,0,0],[0,0,1],[0,2,0]]
+Explanation: The diagram above shows a valid example of a matrix that satisfies all the conditions.
+The row conditions are the following:
+- Number 1 is in row 1, and number 2 is in row 2, so 1 is above 2 in the matrix.
+- Number 3 is in row 0, and number 2 is in row 2, so 3 is above 2 in the matrix.
+The column conditions are the following:
+- Number 2 is in column 1, and number 1 is in column 2, so 2 is left of 1 in the matrix.
+- Number 3 is in column 0, and number 2 is in column 1, so 3 is left of 2 in the matrix.
+Note that there may be multiple correct answers.
+```
+
+Example 2:
+
+```
+Input: k = 3, rowConditions = [[1,2],[2,3],[3,1],[2,3]], colConditions = [[2,1]]
+Output: []
+Explanation: From the first two conditions, 3 has to be below 1 but the third conditions needs 3 to be above 1 to be satisfied.
+No matrix can satisfy all the conditions, so we return the empty matrix.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `2 <= k <= 400`
+	
+- `1 <= rowConditions.length, colConditions.length <= 104`
+	
+- `rowConditions[i].length == colConditions[i].length == 2`
+	
+- `1 <= abovei, belowi, lefti, righti <= k`
+	
+- `abovei != belowi`
+	
+- `lefti != righti`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} k
+ * @param {number[][]} rowConditions
+ * @param {number[][]} colConditions
+ * @return {number[][]}
+ */
+var buildMatrix = function(k, rowConditions, colConditions) {
+    var rowOrder = topologicalSort(k, rowConditions);
+    var colOrder = topologicalSort(k, colConditions);
+    if (!rowOrder || !colOrder) return [];
+    var colOrderMap = colOrder.reduce((map, n, i) => {
+        map[n] = i;
+        return map;
+    }, {});
+    var matrix = Array(k).fill(0).map(() => Array(k).fill(0));
+    rowOrder.forEach((n, i) => matrix[i][colOrderMap[n]] = n);
+    return matrix;
+};
+
+var topologicalSort = function(k, arr) {
+    var beforeMap = Array(k).fill(0);
+    var afterMap = Array(k).fill(0).map(() => []);
+    for (var i = 0; i < arr.length; i++) {
+        beforeMap[arr[i][1] - 1] += 1;
+        afterMap[arr[i][0] - 1].push(arr[i][1]);
+    }
+    var queue = [];
+    for (var j = 0; j < k; j++) {
+        if (beforeMap[j] === 0) {
+            queue.push(j + 1);
+        }
+    }
+    var res = [];
+    while (queue.length) {
+        var num = queue.shift();
+        afterMap[num - 1].forEach(n => {
+            if (--beforeMap[n - 1] === 0) {
+                queue.push(n);
+            }
+        });
+        res.push(num);
+    }
+    if (res.length === k) {
+        return res;
+    }
+    return null;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(k).
+* Space complexity : O(k ^ 2).