From 2acfd08cb4001564293950c36663139a9cabf749 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Mon, 24 Jun 2024 16:09:59 +0800 Subject: [PATCH 1/2] feat: add solutions to lc problem: No.3197 No.3197.Find the Minimum Area to Cover All Ones II --- .../README.md | 281 +++++++++++++++++- .../README_EN.md | 281 +++++++++++++++++- .../Solution.cpp | 47 +++ .../Solution.go | 48 +++ .../Solution.java | 50 ++++ .../Solution.py | 56 ++++ .../Solution.ts | 56 ++++ 7 files changed, 811 insertions(+), 8 deletions(-) create mode 100644 solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.cpp create mode 100644 solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.go create mode 100644 solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java create mode 100644 solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.py create mode 100644 solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.ts diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md index 885ddf77abd4d..0176b8d7fda18 100644 --- a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md @@ -74,32 +74,305 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3197.Fi -### 方法一 +### 方法一：枚举 + +根据题目描述，我们可以用两条分割线，将矩形分成三个部分，我们分别计算每一部分包含所有 $1$ 的最小矩形面积，然后取三个部分面积之和的最小值。 + +我们可以枚举两条分割线的位置，共有 $6$ 种情况： + +1. 两次横向分割 +1. 两次纵向分割 +1. 先进行一次横向分割，再对上部分进行一次纵向分割 +1. 先进行一次横向分割，再对下部分进行一次纵向分割 +1. 先进行一次纵向分割，再对左部分进行一次横向分割 +1. 先进行一次纵向分割，再对右部分进行一次横向分割 + +我们可以用一个函数 $\text{f}(i_1, j_1, i_2, j_2)$ 来计算矩形 $(i_1, j_1)$ 到 $(i_2, j_2)$ 包含所有 $1$ 的最小矩形面积。 + +时间复杂度 $O(m^2 \times n^2)$，其中 $m$ 和 $n$ 分别是矩形的行数和列数。空间复杂度 $O(1)$。 #### Python3 ```python - +class Solution: + def minimumSum(self, grid: List[List[int]]) -> int: + def f(i1: int, j1: int, i2: int, j2: int) -> int: + x1 = y1 = inf + x2 = y2 = -inf + for i in range(i1, i2 + 1): + for j in range(j1, j2 + 1): + if grid[i][j] == 1: + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + return (x2 - x1 + 1) * (y2 - y1 + 1) + + m, n = len(grid), len(grid[0]) + ans = m * n + for i1 in range(m - 1): + for i2 in range(i1 + 1, m - 1): + ans = min( + ans, + f(0, 0, i1, n - 1) + + f(i1 + 1, 0, i2, n - 1) + + f(i2 + 1, 0, m - 1, n - 1), + ) + for j1 in range(n - 1): + for j2 in range(j1 + 1, n - 1): + ans = min( + ans, + f(0, 0, m - 1, j1) + + f(0, j1 + 1, m - 1, j2) + + f(0, j2 + 1, m - 1, n - 1), + ) + for i in range(m - 1): + for j in range(n - 1): + ans = min( + ans, + f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, i, n - 1) + + f(i + 1, 0, m - 1, j) + + f(i + 1, j + 1, m - 1, n - 1), + ) + + ans = min( + ans, + f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, m - 1, j) + + f(0, j + 1, i, n - 1) + + f(i + 1, j + 1, m - 1, n - 1), + ) + return ans ``` #### Java ```java - +class Solution { + private final int inf = 1 << 30; + private int[][] grid; + + public int minimumSum(int[][] grid) { + this.grid = grid; + int m = grid.length; + int n = grid[0].length; + int ans = m * n; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + return ans; + } + + private int f(int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return (x2 - x1 + 1) * (y2 - y1 + 1); + } +} ``` #### C++ ```cpp - +class Solution { +public: + int minimumSum(vector>& grid) { + int m = grid.size(); + int n = grid[0].size(); + int ans = m * n; + int inf = INT_MAX / 4; + auto f = [&](int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = min(x1, i); + y1 = min(y1, j); + x2 = max(x2, i); + y2 = max(y2, j); + } + } + } + return x1 > x2 || y1 > y2 ? inf : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + + return ans; + } +}; ``` #### Go ```go +func minimumSum(grid [][]int) int { + m := len(grid) + n := len(grid[0]) + ans := m * n + inf := math.MaxInt32 + + f := func(i1, j1, i2, j2 int) int { + x1, y1 := inf, inf + x2, y2 := -inf, -inf + for i := i1; i <= i2; i++ { + for j := j1; j <= j2; j++ { + if grid[i][j] == 1 { + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + } + } + } + if x1 == inf { + return 0 + } + return (x2 - x1 + 1) * (y2 - y1 + 1) + } + + for i1 := 0; i1 < m-1; i1++ { + for i2 := i1 + 1; i2 < m-1; i2++ { + ans = min(ans, f(0, 0, i1, n-1)+f(i1+1, 0, i2, n-1)+f(i2+1, 0, m-1, n-1)) + } + } + + for j1 := 0; j1 < n-1; j1++ { + for j2 := j1 + 1; j2 < n-1; j2++ { + ans = min(ans, f(0, 0, m-1, j1)+f(0, j1+1, m-1, j2)+f(0, j2+1, m-1, n-1)) + } + } + + for i := 0; i < m-1; i++ { + for j := 0; j < n-1; j++ { + ans = min(ans, f(0, 0, i, j)+f(0, j+1, i, n-1)+f(i+1, 0, m-1, n-1)) + ans = min(ans, f(0, 0, i, n-1)+f(i+1, 0, m-1, j)+f(i+1, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, i, j)+f(i+1, 0, m-1, j)+f(0, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, m-1, j)+f(0, j+1, i, n-1)+f(i+1, j+1, m-1, n-1)) + } + } + + return ans +} +``` +#### TypeScript + +```ts +function minimumSum(grid: number[][]): number { + const m = grid.length; + const n = grid[0].length; + let ans = m * n; + const inf = Number.MAX_SAFE_INTEGER; + const f = (i1: number, j1: number, i2: number, j2: number): number => { + let [x1, y1] = [inf, inf]; + let [x2, y2] = [-inf, -inf]; + for (let i = i1; i <= i2; i++) { + for (let j = j1; j <= j2; j++) { + if (grid[i][j] === 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return x1 === inf ? 0 : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (let i1 = 0; i1 < m - 1; i1++) { + for (let i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min( + ans, + f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1), + ); + } + } + + for (let j1 = 0; j1 < n - 1; j1++) { + for (let j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min( + ans, + f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1), + ); + } + } + + for (let i = 0; i < m - 1; i++) { + for (let j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1), + ); + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1), + ); + } + } + + return ans; +} ``` diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md index 8c3cfce08e98a..2ef3e75f7e798 100644 --- a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md @@ -72,32 +72,305 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3197.Fi -### Solution 1 +### Solution 1: Enumeration + +According to the problem description, we can use two dividing lines to split the rectangle into three parts. We calculate the minimum rectangular area containing all $1$s for each part and then take the minimum sum of the areas of the three parts. + +We can enumerate the positions of the two dividing lines, which have $6$ possibilities: + +1. Two horizontal splits +2. Two vertical splits +3. First perform a horizontal split, then a vertical split on the upper part +4. First perform a horizontal split, then a vertical split on the lower part +5. First perform a vertical split, then a horizontal split on the left part +6. First perform a vertical split, then a horizontal split on the right part + +We can use a function $\text{f}(i_1, j_1, i_2, j_2)$ to calculate the minimum rectangular area containing all $1$s from $(i_1, j_1)$ to $(i_2, j_2)$. + +The time complexity is $O(m^2 \times n^2)$, where $m$ and $n$ are the number of rows and columns of the rectangle, respectively. The space complexity is $O(1)$. #### Python3 ```python - +class Solution: + def minimumSum(self, grid: List[List[int]]) -> int: + def f(i1: int, j1: int, i2: int, j2: int) -> int: + x1 = y1 = inf + x2 = y2 = -inf + for i in range(i1, i2 + 1): + for j in range(j1, j2 + 1): + if grid[i][j] == 1: + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + return (x2 - x1 + 1) * (y2 - y1 + 1) + + m, n = len(grid), len(grid[0]) + ans = m * n + for i1 in range(m - 1): + for i2 in range(i1 + 1, m - 1): + ans = min( + ans, + f(0, 0, i1, n - 1) + + f(i1 + 1, 0, i2, n - 1) + + f(i2 + 1, 0, m - 1, n - 1), + ) + for j1 in range(n - 1): + for j2 in range(j1 + 1, n - 1): + ans = min( + ans, + f(0, 0, m - 1, j1) + + f(0, j1 + 1, m - 1, j2) + + f(0, j2 + 1, m - 1, n - 1), + ) + for i in range(m - 1): + for j in range(n - 1): + ans = min( + ans, + f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, i, n - 1) + + f(i + 1, 0, m - 1, j) + + f(i + 1, j + 1, m - 1, n - 1), + ) + + ans = min( + ans, + f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, m - 1, j) + + f(0, j + 1, i, n - 1) + + f(i + 1, j + 1, m - 1, n - 1), + ) + return ans ``` #### Java ```java - +class Solution { + private final int inf = 1 << 30; + private int[][] grid; + + public int minimumSum(int[][] grid) { + this.grid = grid; + int m = grid.length; + int n = grid[0].length; + int ans = m * n; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + return ans; + } + + private int f(int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return (x2 - x1 + 1) * (y2 - y1 + 1); + } +} ``` #### C++ ```cpp - +class Solution { +public: + int minimumSum(vector>& grid) { + int m = grid.size(); + int n = grid[0].size(); + int ans = m * n; + int inf = INT_MAX / 4; + auto f = [&](int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = min(x1, i); + y1 = min(y1, j); + x2 = max(x2, i); + y2 = max(y2, j); + } + } + } + return x1 > x2 || y1 > y2 ? inf : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + + return ans; + } +}; ``` #### Go ```go +func minimumSum(grid [][]int) int { + m := len(grid) + n := len(grid[0]) + ans := m * n + inf := math.MaxInt32 + + f := func(i1, j1, i2, j2 int) int { + x1, y1 := inf, inf + x2, y2 := -inf, -inf + for i := i1; i <= i2; i++ { + for j := j1; j <= j2; j++ { + if grid[i][j] == 1 { + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + } + } + } + if x1 == inf { + return 0 + } + return (x2 - x1 + 1) * (y2 - y1 + 1) + } + + for i1 := 0; i1 < m-1; i1++ { + for i2 := i1 + 1; i2 < m-1; i2++ { + ans = min(ans, f(0, 0, i1, n-1)+f(i1+1, 0, i2, n-1)+f(i2+1, 0, m-1, n-1)) + } + } + + for j1 := 0; j1 < n-1; j1++ { + for j2 := j1 + 1; j2 < n-1; j2++ { + ans = min(ans, f(0, 0, m-1, j1)+f(0, j1+1, m-1, j2)+f(0, j2+1, m-1, n-1)) + } + } + + for i := 0; i < m-1; i++ { + for j := 0; j < n-1; j++ { + ans = min(ans, f(0, 0, i, j)+f(0, j+1, i, n-1)+f(i+1, 0, m-1, n-1)) + ans = min(ans, f(0, 0, i, n-1)+f(i+1, 0, m-1, j)+f(i+1, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, i, j)+f(i+1, 0, m-1, j)+f(0, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, m-1, j)+f(0, j+1, i, n-1)+f(i+1, j+1, m-1, n-1)) + } + } + + return ans +} +``` +#### TypeScript + +```ts +function minimumSum(grid: number[][]): number { + const m = grid.length; + const n = grid[0].length; + let ans = m * n; + const inf = Number.MAX_SAFE_INTEGER; + const f = (i1: number, j1: number, i2: number, j2: number): number => { + let [x1, y1] = [inf, inf]; + let [x2, y2] = [-inf, -inf]; + for (let i = i1; i <= i2; i++) { + for (let j = j1; j <= j2; j++) { + if (grid[i][j] === 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return x1 === inf ? 0 : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (let i1 = 0; i1 < m - 1; i1++) { + for (let i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min( + ans, + f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1), + ); + } + } + + for (let j1 = 0; j1 < n - 1; j1++) { + for (let j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min( + ans, + f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1), + ); + } + } + + for (let i = 0; i < m - 1; i++) { + for (let j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1), + ); + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1), + ); + } + } + + return ans; +} ``` diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.cpp b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.cpp new file mode 100644 index 0000000000000..517105d9476da --- /dev/null +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.cpp @@ -0,0 +1,47 @@ +class Solution { +public: + int minimumSum(vector>& grid) { + int m = grid.size(); + int n = grid[0].size(); + int ans = m * n; + int inf = INT_MAX / 4; + auto f = [&](int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = min(x1, i); + y1 = min(y1, j); + x2 = max(x2, i); + y2 = max(y2, j); + } + } + } + return x1 > x2 || y1 > y2 ? inf : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + + return ans; + } +}; \ No newline at end of file diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.go b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.go new file mode 100644 index 0000000000000..847b611c0f37d --- /dev/null +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.go @@ -0,0 +1,48 @@ +func minimumSum(grid [][]int) int { + m := len(grid) + n := len(grid[0]) + ans := m * n + inf := math.MaxInt32 + + f := func(i1, j1, i2, j2 int) int { + x1, y1 := inf, inf + x2, y2 := -inf, -inf + for i := i1; i <= i2; i++ { + for j := j1; j <= j2; j++ { + if grid[i][j] == 1 { + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + } + } + } + if x1 == inf { + return 0 + } + return (x2 - x1 + 1) * (y2 - y1 + 1) + } + + for i1 := 0; i1 < m-1; i1++ { + for i2 := i1 + 1; i2 < m-1; i2++ { + ans = min(ans, f(0, 0, i1, n-1)+f(i1+1, 0, i2, n-1)+f(i2+1, 0, m-1, n-1)) + } + } + + for j1 := 0; j1 < n-1; j1++ { + for j2 := j1 + 1; j2 < n-1; j2++ { + ans = min(ans, f(0, 0, m-1, j1)+f(0, j1+1, m-1, j2)+f(0, j2+1, m-1, n-1)) + } + } + + for i := 0; i < m-1; i++ { + for j := 0; j < n-1; j++ { + ans = min(ans, f(0, 0, i, j)+f(0, j+1, i, n-1)+f(i+1, 0, m-1, n-1)) + ans = min(ans, f(0, 0, i, n-1)+f(i+1, 0, m-1, j)+f(i+1, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, i, j)+f(i+1, 0, m-1, j)+f(0, j+1, m-1, n-1)) + ans = min(ans, f(0, 0, m-1, j)+f(0, j+1, i, n-1)+f(i+1, j+1, m-1, n-1)) + } + } + + return ans +} \ No newline at end of file diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java new file mode 100644 index 0000000000000..633d0dd56fbd1 --- /dev/null +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java @@ -0,0 +1,50 @@ +class Solution { + private final int inf = 1 << 30; + private int[][] grid; + + public int minimumSum(int[][] grid) { + this.grid = grid; + int m = grid.length; + int n = grid[0].length; + int ans = m * n; + + for (int i1 = 0; i1 < m - 1; i1++) { + for (int i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + } + } + + for (int j1 = 0; j1 < n - 1; j1++) { + for (int j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + } + } + + for (int i = 0; i < m - 1; i++) { + for (int j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + } + } + return ans; + } + + private int f(int i1, int j1, int i2, int j2) { + int x1 = inf, y1 = inf; + int x2 = -inf, y2 = -inf; + for (int i = i1; i <= i2; i++) { + for (int j = j1; j <= j2; j++) { + if (grid[i][j] == 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return (x2 - x1 + 1) * (y2 - y1 + 1); + } +} \ No newline at end of file diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.py b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.py new file mode 100644 index 0000000000000..dd514a9c437db --- /dev/null +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.py @@ -0,0 +1,56 @@ +class Solution: + def minimumSum(self, grid: List[List[int]]) -> int: + def f(i1: int, j1: int, i2: int, j2: int) -> int: + x1 = y1 = inf + x2 = y2 = -inf + for i in range(i1, i2 + 1): + for j in range(j1, j2 + 1): + if grid[i][j] == 1: + x1 = min(x1, i) + y1 = min(y1, j) + x2 = max(x2, i) + y2 = max(y2, j) + return (x2 - x1 + 1) * (y2 - y1 + 1) + + m, n = len(grid), len(grid[0]) + ans = m * n + for i1 in range(m - 1): + for i2 in range(i1 + 1, m - 1): + ans = min( + ans, + f(0, 0, i1, n - 1) + + f(i1 + 1, 0, i2, n - 1) + + f(i2 + 1, 0, m - 1, n - 1), + ) + for j1 in range(n - 1): + for j2 in range(j1 + 1, n - 1): + ans = min( + ans, + f(0, 0, m - 1, j1) + + f(0, j1 + 1, m - 1, j2) + + f(0, j2 + 1, m - 1, n - 1), + ) + for i in range(m - 1): + for j in range(n - 1): + ans = min( + ans, + f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, i, n - 1) + + f(i + 1, 0, m - 1, j) + + f(i + 1, j + 1, m - 1, n - 1), + ) + + ans = min( + ans, + f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1), + ) + ans = min( + ans, + f(0, 0, m - 1, j) + + f(0, j + 1, i, n - 1) + + f(i + 1, j + 1, m - 1, n - 1), + ) + return ans diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.ts b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.ts new file mode 100644 index 0000000000000..e31ef4e75437e --- /dev/null +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.ts @@ -0,0 +1,56 @@ +function minimumSum(grid: number[][]): number { + const m = grid.length; + const n = grid[0].length; + let ans = m * n; + const inf = Number.MAX_SAFE_INTEGER; + const f = (i1: number, j1: number, i2: number, j2: number): number => { + let [x1, y1] = [inf, inf]; + let [x2, y2] = [-inf, -inf]; + for (let i = i1; i <= i2; i++) { + for (let j = j1; j <= j2; j++) { + if (grid[i][j] === 1) { + x1 = Math.min(x1, i); + y1 = Math.min(y1, j); + x2 = Math.max(x2, i); + y2 = Math.max(y2, j); + } + } + } + return x1 === inf ? 0 : (x2 - x1 + 1) * (y2 - y1 + 1); + }; + + for (let i1 = 0; i1 < m - 1; i1++) { + for (let i2 = i1 + 1; i2 < m - 1; i2++) { + ans = Math.min( + ans, + f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1), + ); + } + } + + for (let j1 = 0; j1 < n - 1; j1++) { + for (let j2 = j1 + 1; j2 < n - 1; j2++) { + ans = Math.min( + ans, + f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1), + ); + } + } + + for (let i = 0; i < m - 1; i++) { + for (let j = 0; j < n - 1; j++) { + ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1), + ); + ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, + f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1), + ); + } + } + + return ans; +} From a6ab46a57e012b9662df2aa1cd7a81cd12fae5bf Mon Sep 17 00:00:00 2001 From: yanglbme Date: Mon, 24 Jun 2024 16:15:13 +0800 Subject: [PATCH 2/2] fix: java code --- .../README.md | 20 ++++++++++++------- .../README_EN.md | 20 ++++++++++++------- .../Solution.java | 20 ++++++++++++------- 3 files changed, 39 insertions(+), 21 deletions(-) diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md index 0176b8d7fda18..a3bc85fb093e4 100644 --- a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md @@ -169,23 +169,29 @@ class Solution { for (int i1 = 0; i1 < m - 1; i1++) { for (int i2 = i1 + 1; i2 < m - 1; i2++) { - ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); } } for (int j1 = 0; j1 < n - 1; j1++) { for (int j2 = j1 + 1; j2 < n - 1; j2++) { - ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); } } for (int i = 0; i < m - 1; i++) { for (int j = 0; j < n - 1; j++) { - ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); - - ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min( + ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); } } return ans; diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md index 2ef3e75f7e798..2fd94d86ceff4 100644 --- a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README_EN.md @@ -167,23 +167,29 @@ class Solution { for (int i1 = 0; i1 < m - 1; i1++) { for (int i2 = i1 + 1; i2 < m - 1; i2++) { - ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); } } for (int j1 = 0; j1 < n - 1; j1++) { for (int j2 = j1 + 1; j2 < n - 1; j2++) { - ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); } } for (int i = 0; i < m - 1; i++) { for (int j = 0; j < n - 1; j++) { - ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); - - ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min( + ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); } } return ans; diff --git a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java index 633d0dd56fbd1..cd5a0b646223f 100644 --- a/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java +++ b/solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/Solution.java @@ -10,23 +10,29 @@ public int minimumSum(int[][] grid) { for (int i1 = 0; i1 < m - 1; i1++) { for (int i2 = i1 + 1; i2 < m - 1; i2++) { - ans = Math.min(ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1)); } } for (int j1 = 0; j1 < n - 1; j1++) { for (int j2 = j1 + 1; j2 < n - 1; j2++) { - ans = Math.min(ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1)); } } for (int i = 0; i < m - 1; i++) { for (int j = 0; j < n - 1; j++) { - ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); - - ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); - ans = Math.min(ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1)); + + ans = Math.min( + ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1)); + ans = Math.min( + ans, f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1)); } } return ans;