update sth

Author: BruceYuj

docs/ondoing/1139.md

@@ -0,0 +1,184 @@
+
+
+## 暴力法
+在做这道题目之前，我们先看数据规模 $10^2$，很小。
+
+我们分析题意，题意要求是 **边界全部为 1 的最大正方形**。
+
+从这个题意我们可以看出什么？
+1. 什么是正方形？或者正方形可以有什么来决定？
+  - 左上角和右下角可以决定一个矩形，然后长和宽决定该矩形是否是正方形
+
+2. 限定条件是边长上面都是 1
+
+因此，本题的暴力求解是：
+1. 枚举所有的左上角和右下角
+   - 判断是否能够构成正方形
+   - 判断正方形的边长上是否都是 1
+
+写出套路就是：
+```
+for 所有的左上角：
+  for 所有的右下角：
+    if(左上角+右下角能构成正方形) {
+      tmp = isValid(正方形是否边长上都是 1)
+      if(tmp) {
+        则更新答案
+      }
+    }
+
+```
+
+```javascript
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var largest1BorderedSquare = function(grid) {
+    if(!grid.length || !grid[0].length) return 0;
+
+    let m = grid.length;
+    let n = grid[0].length;
+    let ans = 0;
+
+    for(let i = 0; i < m; i++) {
+        for(let j = 0; j < n; j++) {
+            for(let k = i; k < m; k++) {
+                for(let p = j; p < n; p++) {
+                    if(k - i !== p - j) continue;
+                    let tmp = isValid(i,j,k,p);
+                    if(tmp) ans = Math.max(ans, k-i+1);
+
+                }
+            }
+        }
+    }
+
+    return ans * ans;
+
+    function isValid(i,j,k,p) {
+        for(let m = i; m <= k; m++) {
+            if(!grid[m][j] || !grid[m][p]) return false;
+        }
+
+        for(let m = j; m <= p; m++) {
+            if(!grid[i][m] || !grid[k][m]) return false;
+        }
+
+        return true;
+    }
+};
+```
+
+**复杂度分析**:
+- 时间复杂度： $O(m*n*min(m,n)^2 + m^2*n^2)$
+- 空间复杂度：$O(1)$
+
+在上面我们的算法当中，是可以优化的。
+我们在上面的做法是同时枚举所有的**左上角** 和 **右下角**。
+其实我们将右下角换成对于正方形边长的枚举，这样会减少不少的判断。
+
+```
+for 所有的左上角：
+  for 所有的可能正方形边长：
+      tmp = isValid(正方形是否边长上都是 1)
+      if(tmp) {
+        则更新答案
+      }
+
+```
+
+核心代码变为：
+```javascript
+
+    for(let i = 0; i < m; i++) {
+        for(let j = 0; j < n; j++) {
+            let len = Math.min(m-i, n-j);
+            for(let k = 1; k <= len; k++) {
+                let tmp = isValid(i,j,k);
+                if(tmp) ans = Math.max(ans, k);
+            }
+        }
+    }
+```
+
+- 时间复杂度： $O(m*n*min(m,n)^2)$
+
+
+## 动态规划
+你会发现，每次变动一下左上角，所有的边长我们都得重新判断。我们是否能够保留上次的计算结果来避免重复运算呢。
+
+真正符合题目要求的边长都是 1，因此我们可以通过这个得到一个问题：所有符合要求的正方形边长，为左上角开始的最大连续 1 的个数（左边和下边）。
+
+在这里，我们可以枚举右下角，求右下角的左边和上边的最长连续 1 的个数。这样，我们可以缓存已经枚举过点的结果。
+
+$$
+up[i][j] = 
+\begin{cases}
+0, grid[i][j] = 0 \\
+up[i-1][j] + 1, grid[i][j] = 1
+\end{cases}
+$$
+
+$$
+left[i][j] = 
+\begin{cases}
+0, grid[i][j] = 0 \\
+left[i][j-1] + 1, grid[i][j] = 1
+\end{cases}
+$$
+
+如何判断这个正方形呢？
+1. 下边和右边，由 $len = Math.min(left[i][j], up[i][j])$ 决定, 然后枚举 $[len ,1]$ 找到第一个符合要求的边长
+2. 上边和左边，可以分别通过右上角的 left 和左下角的 up 来获取。
+
+这样，我们就将 $isValid$ 的时间复杂度降低到了 $O(1)$
+
+
+```javascript
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var largest1BorderedSquare = function(grid) {
+    if(!grid.length || !grid[0].length) return 0;
+
+    let m = grid.length;
+    let n = grid[0].length;
+    let ans = 0;
+
+    let up = new Array(m+1);
+    let left = new Array(m+1);
+
+    for(let i = 0; i <= m; i++) {
+        up[i] = new Array(n+1).fill(0);
+        left[i] = new Array(n+1).fill(0);
+    }
+
+    for(let i = 0; i < m; i++) {
+        for(let j = 0; j < n; j++) {
+            if(grid[i][j] === 1) {
+                up[i+1][j+1] = up[i][j+1] + 1
+                left[i+1][j+1] = left[i+1][j] + 1;
+
+                let len = Math.min(up[i+1][j+1], left[i+1][j+1]);
+
+                while(len) {
+                    if (i+1 >= len && j+1 >= len &&left[i-len+2][j+1] >= len && up[i+1][j-len+2] >= len) break;
+
+                    len--;
+                }
+                ans = Math.max(ans, len);
+
+            }
+        }
+    }
+
+    return ans * ans;
+};
+
+```
+
+**复杂度分析**:
+- 时间复杂度： $O(m*n*min(m,n))$
+- 空间复杂度：$O(m*n)$

docs/ondoing/740.md

@@ -0,0 +1,53 @@
+
+## 动态规划
+转换成小偷问题。
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var deleteAndEarn = function(nums) {
+    let counter = new Array(10001).fill(0);
+
+    for(let i = 0; i < nums.length; i++) {
+        counter[nums[i]]++;
+    }
+
+    let dp = new Array(counter.length).fill(0);
+
+    dp[1] = counter[1];
+    for(let i = 2; i < counter.length; i++) {
+        dp[i] = Math.max(dp[i-1], dp[i-2] + counter[i]*i);
+    }
+
+    return dp[counter.length-1];
+};
+```
+
+**滚动数组优化**
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var deleteAndEarn = function(nums) {
+    let counter = new Array(10001).fill(0);
+
+    for(let i = 0; i < nums.length; i++) {
+        counter[nums[i]]++;
+    }
+
+    let dp0 = 0;
+    let dp1 = counter[1];
+
+    for(let i = 2; i < counter.length; i++) {
+        let tmp = dp1;
+        dp1 = Math.max(dp1, dp0 + counter[i]*i);
+        dp0 = tmp;
+    }
+
+    return dp1;
+};
+```