feat: add solutions to lc problem: No.0807. Max Increase to Keep City

Skyline

Author: yanglbme

solution/0800-0899/0807.Max Increase to Keep City Skyline/README.md

@@ -42,27 +42,121 @@ gridNew = [ [8, 4, 8, 7],
 	<li>一座建筑物占据一个<code>grid[i][j]</code>：换言之，它们是 <code>1 x 1 x grid[i][j]</code> 的长方体。</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+先求出东西方向 we 每一行的最大值、南北方向 ns 每一列的最大值。
+
+然后遍历二维数组 grid，对于每个元素，能增加的最大高度是 `min(we[i], ns[j]) - grid[i][j]`。累加所有元素能增加的最大高度即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        we = [max(item) for item in grid]
+        ns = [max([grid[i][j] for i in range(m)]) for j in range(n)]
+        res = 0
+        for i in range(m):
+            for j in range(n):
+                res += min(we[i], ns[j]) - grid[i][j]
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int maxIncreaseKeepingSkyline(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int[] we = new int[m];
+        int[] ns = new int[n];
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = Math.max(we[i], grid[i][j]);
+                ns[j] = Math.max(ns[j], grid[i][j]);
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += Math.min(we[i], ns[j]) - grid[i][j];
+            }
+        }
+        return res;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<int> we(m, 0);
+        vector<int> ns(n, 0);
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = max(we[i], grid[i][j]);
+                ns[j] = max(ns[j], grid[i][j]);
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += min(we[i], ns[j]) - grid[i][j];
+            }
+        }
+        return res;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maxIncreaseKeepingSkyline(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	we := make([]int, m)
+	ns := make([]int, n)
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			we[i] = max(we[i], grid[i][j])
+			ns[j] = max(ns[j], grid[i][j])
+		}
+	}
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			res += min(we[i], ns[j]) - grid[i][j]
+		}
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0807.Max Increase to Keep City Skyline/README_EN.md

@@ -6,16 +6,10 @@
 
 <p>In a 2 dimensional array <code>grid</code>, each value <code>grid[i][j]</code> represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts&nbsp;can be different for different buildings). Height&nbsp;0 is considered to be a&nbsp;building&nbsp;as well.&nbsp;</p>
 
-
-
 <p>At the end, the &quot;skyline&quot; when viewed from all four directions&nbsp;of the grid, i.e.&nbsp;top, bottom, left, and right,&nbsp;must be the same as the&nbsp;skyline of the original grid. A city&#39;s skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See&nbsp;the following example.</p>
 
-
-
 <p>What is the maximum total sum that the height of the buildings can be increased?</p>
 
-
-
 <pre>
 
 <strong>Example:</strong>
@@ -60,34 +54,119 @@ gridNew = [ [8, 4, 8, 7],
 
 </pre>
 
-
-
 <p><strong>Notes: </strong></p>
 
-
-
 <ul>
 	<li><code>1 &lt; grid.length = grid[0].length &lt;= 50</code>.</li>
 	<li>All heights <code>grid[i][j]</code> are in the range <code>[0, 100]</code>.</li>
 	<li>All buildings in <code>grid[i][j]</code> occupy the entire grid cell: that is, they are a <code>1 x 1 x grid[i][j]</code> rectangular prism.</li>
 </ul>
 
-
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        we = [max(item) for item in grid]
+        ns = [max([grid[i][j] for i in range(m)]) for j in range(n)]
+        res = 0
+        for i in range(m):
+            for j in range(n):
+                res += min(we[i], ns[j]) - grid[i][j]
+        return res
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int maxIncreaseKeepingSkyline(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int[] we = new int[m];
+        int[] ns = new int[n];
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = Math.max(we[i], grid[i][j]);
+                ns[j] = Math.max(ns[j], grid[i][j]);
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += Math.min(we[i], ns[j]) - grid[i][j];
+            }
+        }
+        return res;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<int> we(m, 0);
+        vector<int> ns(n, 0);
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = max(we[i], grid[i][j]);
+                ns[j] = max(ns[j], grid[i][j]);
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += min(we[i], ns[j]) - grid[i][j];
+            }
+        }
+        return res;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maxIncreaseKeepingSkyline(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	we := make([]int, m)
+	ns := make([]int, n)
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			we[i] = max(we[i], grid[i][j])
+			ns[j] = max(ns[j], grid[i][j])
+		}
+	}
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			res += min(we[i], ns[j]) - grid[i][j]
+		}
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0807.Max Increase to Keep City Skyline/Solution.cpp

@@ -1,29 +1,21 @@
 class Solution {
 public:
-    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) 
-    {
-
-        vector<int> h(grid.size(), -1), w(grid[0]) ;
-        
-        for (int i = 0; i < grid.size(); ++i)
-            for (int j = 0; j < grid[i].size(); ++j)
-            {
-                if (grid[i][j] > h[i])
-                    h[i] = grid[i][j] ;
-                if (grid[i][j] > w[j])
-                    w[j] = grid[i][j] ;
+    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<int> we(m, 0);
+        vector<int> ns(n, 0);
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = max(we[i], grid[i][j]);
+                ns[j] = max(ns[j], grid[i][j]);
             }
-        int sum = 0 ;
-        
-        for (int i = 0; i < grid.size(); ++i)
-            for (int j = 0; j < grid.size(); ++j)
-            {
-                int m = h[i] < w[j]? h[i]: w[j] ;
-                if (grid[i][j] < m)
-                    sum += m - grid[i][j] ;
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += min(we[i], ns[j]) - grid[i][j];
             }
-        
-        
-        return sum ;
+        }
+        return res;
     }
-};
+};

solution/0800-0899/0807.Max Increase to Keep City Skyline/Solution.go

@@ -0,0 +1,32 @@
+func maxIncreaseKeepingSkyline(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	we := make([]int, m)
+	ns := make([]int, n)
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			we[i] = max(we[i], grid[i][j])
+			ns[j] = max(ns[j], grid[i][j])
+		}
+	}
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			res += min(we[i], ns[j]) - grid[i][j]
+		}
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

solution/0800-0899/0807.Max Increase to Keep City Skyline/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int maxIncreaseKeepingSkyline(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int[] we = new int[m];
+        int[] ns = new int[n];
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                we[i] = Math.max(we[i], grid[i][j]);
+                ns[j] = Math.max(ns[j], grid[i][j]);
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                res += Math.min(we[i], ns[j]) - grid[i][j];
+            }
+        }
+        return res;
+    }
+}

solution/0800-0899/0807.Max Increase to Keep City Skyline/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        we = [max(item) for item in grid]
+        ns = [max([grid[i][j] for i in range(m)]) for j in range(n)]
+        res = 0
+        for i in range(m):
+            for j in range(n):
+                res += min(we[i], ns[j]) - grid[i][j]
+        return res