From 649e5e27e65a1e012b9fa009806703c454d84095 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Thu, 23 Nov 2023 10:40:58 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.1411 No.1411.Number of Ways to Paint N \303\227 3 Grid --- .../README.md" | 319 ++++++++++++++++- .../README_EN.md" | 326 ++++++++++++++++++ .../Solution.ts" | 14 + .../README.md | 28 +- .../README_EN.md | 28 +- .../Solution.cpp | 6 +- .../Solution.go | 8 +- .../Solution.java | 6 +- .../Solution.ts | 8 +- 9 files changed, 681 insertions(+), 62 deletions(-) create mode 100644 "solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/Solution.ts" diff --git "a/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README.md" "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README.md" index dca7939f072ba..bd42052c77dc8 100644 --- "a/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README.md" +++ "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README.md" @@ -67,9 +67,27 @@ - 当状态为 $010$ 型时：下一行可能的状态为：$101$, $102$, $121$, $201$, $202$。这 $5$ 个状态可归纳为 $3$ 个 $010$ 型，$2$ 个 $012$ 型。 - 当状态为 $012$ 型时：下一行可能的状态为：$101$, $120$, $121$, $201$。这 $4$ 个状态可归纳为 $2$ 个 $010$ 型，$2$ 个 $012$ 型。 -综上所述，可以得到：$newf0 = 3 * f0 + 2 * f1$，$newf1 = 2 * f0 + 2 * f1$。 +综上所述，可以得到：$newf0 = 3 \times f0 + 2 \times f1$, $newf1 = 2 \times f0 + 2 \times f1$。 -时间复杂度 $O(n)$。 +时间复杂度 $O(n)$，其中 $n$ 是网格的行数。空间复杂度 $O(1)$。 + +**方法二：状态压缩 + 动态规划** + +我们注意到，网格只有 $3$ 列，那么一行中最多有 $3^3=27$ 种不同的涂色方案。 + +因此，我们定义 $f[i][j]$ 表示前 $i$ 行中，第 $i$ 行的涂色状态为 $j$ 的方案数。状态 $f[i][j]$ 由 $f[i - 1][k]$ 转移而来，其中 $k$ 是第 $i - 1$ 行的涂色状态，且 $k$ 和 $j$ 满足不同颜色相邻的要求。即： + +$$ +f[i][j] = \sum_{k \in \text{valid}(j)} f[i - 1][k] +$$ + +其中 $\text{valid}(j)$ 表示状态 $j$ 的所有合法前驱状态。 + +最终的答案即为 $f[n][j]$ 的总和，其中 $j$ 是任意合法的状态。 + +我们注意到，$f[i][j]$ 只和 $f[i - 1][k]$ 有关，因此我们可以使用滚动数组优化空间复杂度。 + +时间复杂度 $O((m + n) \times 3^{2m})$，空间复杂度 $O(3^m)$。其中 $n$ 和 $m$ 分别是网格的行数和列数。 @@ -89,6 +107,44 @@ class Solution: return (f0 + f1) % mod ``` +```python +class Solution: + def numOfWays(self, n: int) -> int: + def f1(x: int) -> bool: + last = -1 + for _ in range(3): + if x % 3 == last: + return False + last = x % 3 + x //= 3 + return True + + def f2(x: int, y: int) -> bool: + for _ in range(3): + if x % 3 == y % 3: + return False + x //= 3 + y //= 3 + return True + + mod = 10**9 + 7 + m = 27 + valid = {i for i in range(m) if f1(i)} + d = defaultdict(list) + for i in valid: + for j in valid: + if f2(i, j): + d[i].append(j) + f = [int(i in valid) for i in range(m)] + for _ in range(n - 1): + g = [0] * m + for i in valid: + for j in d[i]: + g[j] = (g[j] + f[i]) % mod + f = g + return sum(f) % mod +``` + ### **Java** @@ -109,6 +165,68 @@ class Solution { } ``` +```java +class Solution { + public int numOfWays(int n) { + final int mod = (int) 1e9 + 7; + int m = 27; + Set valid = new HashSet<>(); + int[] f = new int[m]; + for (int i = 0; i < m; ++i) { + if (f1(i)) { + valid.add(i); + f[i] = 1; + } + } + Map> d = new HashMap<>(); + for (int i : valid) { + for (int j : valid) { + if (f2(i, j)) { + d.computeIfAbsent(i, k -> new ArrayList<>()).add(j); + } + } + } + for (int k = 1; k < n; ++k) { + int[] g = new int[m]; + for (int i : valid) { + for (int j : d.getOrDefault(i, List.of())) { + g[j] = (g[j] + f[i]) % mod; + } + } + f = g; + } + int ans = 0; + for (int x : f) { + ans = (ans + x) % mod; + } + return ans; + } + + private boolean f1(int x) { + int last = -1; + for (int i = 0; i < 3; ++i) { + if (x % 3 == last) { + return false; + } + last = x % 3; + x /= 3; + } + return true; + } + + private boolean f2(int x, int y) { + for (int i = 0; i < 3; ++i) { + if (x % 3 == y % 3) { + return false; + } + x /= 3; + y /= 3; + } + return true; + } +} +``` + ### **C++** ```cpp @@ -130,6 +248,69 @@ public: }; ``` +```cpp +class Solution { +public: + int numOfWays(int n) { + int m = 27; + + auto f1 = [&](int x) { + int last = -1; + for (int i = 0; i < 3; ++i) { + if (x % 3 == last) { + return false; + } + last = x % 3; + x /= 3; + } + return true; + }; + auto f2 = [&](int x, int y) { + for (int i = 0; i < 3; ++i) { + if (x % 3 == y % 3) { + return false; + } + x /= 3; + y /= 3; + } + return true; + }; + + const int mod = 1e9 + 7; + unordered_set valid; + vector f(m); + for (int i = 0; i < m; ++i) { + if (f1(i)) { + valid.insert(i); + f[i] = 1; + } + } + unordered_map> d; + for (int i : valid) { + for (int j : valid) { + if (f2(i, j)) { + d[i].push_back(j); + } + } + } + for (int k = 1; k < n; ++k) { + vector g(m); + for (int i : valid) { + for (int j : d[i]) { + g[j] = (g[j] + f[i]) % mod; + } + } + f = move(g); + } + int ans = 0; + for (int x : f) { + ans = (ans + x) % mod; + } + return ans; + } +}; +``` + ### **Go** ```go @@ -146,6 +327,140 @@ func numOfWays(n int) int { } ``` +```go +func numOfWays(n int) (ans int) { + f1 := func(x int) bool { + last := -1 + for i := 0; i < 3; i++ { + if x%3 == last { + return false + } + last = x % 3 + x /= 3 + } + return true + } + f2 := func(x, y int) bool { + for i := 0; i < 3; i++ { + if x%3 == y%3 { + return false + } + x /= 3 + y /= 3 + } + return true + } + m := 27 + valid := map[int]bool{} + f := make([]int, m) + for i := 0; i < m; i++ { + if f1(i) { + valid[i] = true + f[i] = 1 + } + } + d := map[int][]int{} + for i := range valid { + for j := range valid { + if f2(i, j) { + d[i] = append(d[i], j) + } + } + } + const mod int = 1e9 + 7 + for k := 1; k < n; k++ { + g := make([]int, m) + for i := range valid { + for _, j := range d[i] { + g[i] = (g[i] + f[j]) % mod + } + } + f = g + } + for _, x := range f { + ans = (ans + x) % mod + } + return +} +``` + +### **TypeScript** + +```ts +function numOfWays(n: number): number { + const mod: number = 10 ** 9 + 7; + let f0: number = 6; + let f1: number = 6; + + for (let i = 1; i < n; i++) { + const g0: number = (3 * f0 + 2 * f1) % mod; + const g1: number = (2 * f0 + 2 * f1) % mod; + f0 = g0; + f1 = g1; + } + + return (f0 + f1) % mod; +} +``` + +```ts +function numOfWays(n: number): number { + const f1 = (x: number): boolean => { + let last = -1; + for (let i = 0; i < 3; ++i) { + if (x % 3 === last) { + return false; + } + last = x % 3; + x = Math.floor(x / 3); + } + return true; + }; + const f2 = (x: number, y: number): boolean => { + for (let i = 0; i < 3; ++i) { + if (x % 3 === y % 3) { + return false; + } + x = Math.floor(x / 3); + y = Math.floor(y / 3); + } + return true; + }; + const m = 27; + const valid = new Set(); + const f: number[] = Array(m).fill(0); + for (let i = 0; i < m; ++i) { + if (f1(i)) { + valid.add(i); + f[i] = 1; + } + } + const d: Map = new Map(); + for (const i of valid) { + for (const j of valid) { + if (f2(i, j)) { + d.set(i, (d.get(i) || []).concat(j)); + } + } + } + const mod = 10 ** 9 + 7; + for (let k = 1; k < n; ++k) { + const g: number[] = Array(m).fill(0); + for (const i of valid) { + for (const j of d.get(i) || []) { + g[i] = (g[i] + f[j]) % mod; + } + } + f.splice(0, f.length, ...g); + } + let ans = 0; + for (const x of f) { + ans = (ans + x) % mod; + } + return ans; +} +``` + ### **...** ``` diff --git "a/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README_EN.md" "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README_EN.md" index 4b5d520cc9c12..79b1782d4422c 100644 --- "a/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README_EN.md" +++ "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/README_EN.md" @@ -34,6 +34,35 @@ ## Solutions +**Solution 1: Recursion** + +We classify all possible states for each row. According to the principle of symmetry, when a row only has $3$ elements, all legal states are classified as: $010$ type, $012$ type. + +- When the state is $010$ type: The possible states for the next row are: $101$, $102$, $121$, $201$, $202$. These $5$ states can be summarized as $3$ $010$ types and $2$ $012$ types. +- When the state is $012$ type: The possible states for the next row are: $101$, $120$, $121$, $201$. These $4$ states can be summarized as $2$ $010$ types and $2$ $012$ types. + +In summary, we can get: $newf0 = 3 \times f0 + 2 \times f1$, $newf1 = 2 \times f0 + 2 \times f1$. + +The time complexity is $O(n)$, where $n$ is the number of rows in the grid. The space complexity is $O(1)$. + +**Solution 2: State Compression + Dynamic Programming** + +We notice that the grid only has $3$ columns, so there are at most $3^3=27$ different coloring schemes in a row. + +Therefore, we define $f[i][j]$ to represent the number of schemes in the first $i$ rows, where the coloring state of the $i$th row is $j$. The state $f[i][j]$ is transferred from $f[i - 1][k]$, where $k$ is the coloring state of the $i - 1$th row, and $k$ and $j$ meet the requirement of different colors being adjacent. That is: + +$$ +f[i][j] = \sum_{k \in \text{valid}(j)} f[i - 1][k] +$$ + +where $\text{valid}(j)$ represents all legal predecessor states of state $j$. + +The final answer is the sum of $f[n][j]$, where $j$ is any legal state. + +We notice that $f[i][j]$ is only related to $f[i - 1][k]$, so we can use a rolling array to optimize the space complexity. + +The time complexity is $O((m + n) \times 3^{2m})$, and the space complexity is $O(3^m)$. Here, $m$ and $n$ are the number of rows and columns of the grid, respectively. + ### **Python3** @@ -50,6 +79,44 @@ class Solution: return (f0 + f1) % mod ``` +```python +class Solution: + def numOfWays(self, n: int) -> int: + def f1(x: int) -> bool: + last = -1 + for _ in range(3): + if x % 3 == last: + return False + last = x % 3 + x //= 3 + return True + + def f2(x: int, y: int) -> bool: + for _ in range(3): + if x % 3 == y % 3: + return False + x //= 3 + y //= 3 + return True + + mod = 10**9 + 7 + m = 27 + valid = {i for i in range(m) if f1(i)} + d = defaultdict(list) + for i in valid: + for j in valid: + if f2(i, j): + d[i].append(j) + f = [int(i in valid) for i in range(m)] + for _ in range(n - 1): + g = [0] * m + for i in valid: + for j in d[i]: + g[j] = (g[j] + f[i]) % mod + f = g + return sum(f) % mod +``` + ### **Java** ```java @@ -68,6 +135,68 @@ class Solution { } ``` +```java +class Solution { + public int numOfWays(int n) { + final int mod = (int) 1e9 + 7; + int m = 27; + Set valid = new HashSet<>(); + int[] f = new int[m]; + for (int i = 0; i < m; ++i) { + if (f1(i)) { + valid.add(i); + f[i] = 1; + } + } + Map> d = new HashMap<>(); + for (int i : valid) { + for (int j : valid) { + if (f2(i, j)) { + d.computeIfAbsent(i, k -> new ArrayList<>()).add(j); + } + } + } + for (int k = 1; k < n; ++k) { + int[] g = new int[m]; + for (int i : valid) { + for (int j : d.getOrDefault(i, List.of())) { + g[j] = (g[j] + f[i]) % mod; + } + } + f = g; + } + int ans = 0; + for (int x : f) { + ans = (ans + x) % mod; + } + return ans; + } + + private boolean f1(int x) { + int last = -1; + for (int i = 0; i < 3; ++i) { + if (x % 3 == last) { + return false; + } + last = x % 3; + x /= 3; + } + return true; + } + + private boolean f2(int x, int y) { + for (int i = 0; i < 3; ++i) { + if (x % 3 == y % 3) { + return false; + } + x /= 3; + y /= 3; + } + return true; + } +} +``` + ### **C++** ```cpp @@ -89,6 +218,69 @@ public: }; ``` +```cpp +class Solution { +public: + int numOfWays(int n) { + int m = 27; + + auto f1 = [&](int x) { + int last = -1; + for (int i = 0; i < 3; ++i) { + if (x % 3 == last) { + return false; + } + last = x % 3; + x /= 3; + } + return true; + }; + auto f2 = [&](int x, int y) { + for (int i = 0; i < 3; ++i) { + if (x % 3 == y % 3) { + return false; + } + x /= 3; + y /= 3; + } + return true; + }; + + const int mod = 1e9 + 7; + unordered_set valid; + vector f(m); + for (int i = 0; i < m; ++i) { + if (f1(i)) { + valid.insert(i); + f[i] = 1; + } + } + unordered_map> d; + for (int i : valid) { + for (int j : valid) { + if (f2(i, j)) { + d[i].push_back(j); + } + } + } + for (int k = 1; k < n; ++k) { + vector g(m); + for (int i : valid) { + for (int j : d[i]) { + g[j] = (g[j] + f[i]) % mod; + } + } + f = move(g); + } + int ans = 0; + for (int x : f) { + ans = (ans + x) % mod; + } + return ans; + } +}; +``` + ### **Go** ```go @@ -105,6 +297,140 @@ func numOfWays(n int) int { } ``` +```go +func numOfWays(n int) (ans int) { + f1 := func(x int) bool { + last := -1 + for i := 0; i < 3; i++ { + if x%3 == last { + return false + } + last = x % 3 + x /= 3 + } + return true + } + f2 := func(x, y int) bool { + for i := 0; i < 3; i++ { + if x%3 == y%3 { + return false + } + x /= 3 + y /= 3 + } + return true + } + m := 27 + valid := map[int]bool{} + f := make([]int, m) + for i := 0; i < m; i++ { + if f1(i) { + valid[i] = true + f[i] = 1 + } + } + d := map[int][]int{} + for i := range valid { + for j := range valid { + if f2(i, j) { + d[i] = append(d[i], j) + } + } + } + const mod int = 1e9 + 7 + for k := 1; k < n; k++ { + g := make([]int, m) + for i := range valid { + for _, j := range d[i] { + g[i] = (g[i] + f[j]) % mod + } + } + f = g + } + for _, x := range f { + ans = (ans + x) % mod + } + return +} +``` + +### **TypeScript** + +```ts +function numOfWays(n: number): number { + const mod: number = 10 ** 9 + 7; + let f0: number = 6; + let f1: number = 6; + + for (let i = 1; i < n; i++) { + const g0: number = (3 * f0 + 2 * f1) % mod; + const g1: number = (2 * f0 + 2 * f1) % mod; + f0 = g0; + f1 = g1; + } + + return (f0 + f1) % mod; +} +``` + +```ts +function numOfWays(n: number): number { + const f1 = (x: number): boolean => { + let last = -1; + for (let i = 0; i < 3; ++i) { + if (x % 3 === last) { + return false; + } + last = x % 3; + x = Math.floor(x / 3); + } + return true; + }; + const f2 = (x: number, y: number): boolean => { + for (let i = 0; i < 3; ++i) { + if (x % 3 === y % 3) { + return false; + } + x = Math.floor(x / 3); + y = Math.floor(y / 3); + } + return true; + }; + const m = 27; + const valid = new Set(); + const f: number[] = Array(m).fill(0); + for (let i = 0; i < m; ++i) { + if (f1(i)) { + valid.add(i); + f[i] = 1; + } + } + const d: Map = new Map(); + for (const i of valid) { + for (const j of valid) { + if (f2(i, j)) { + d.set(i, (d.get(i) || []).concat(j)); + } + } + } + const mod = 10 ** 9 + 7; + for (let k = 1; k < n; ++k) { + const g: number[] = Array(m).fill(0); + for (const i of valid) { + for (const j of d.get(i) || []) { + g[i] = (g[i] + f[j]) % mod; + } + } + f.splice(0, f.length, ...g); + } + let ans = 0; + for (const x of f) { + ans = (ans + x) % mod; + } + return ans; +} +``` + ### **...** ``` diff --git "a/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/Solution.ts" "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/Solution.ts" new file mode 100644 index 0000000000000..25f4bf3da42f0 --- /dev/null +++ "b/solution/1400-1499/1411.Number of Ways to Paint N \303\227 3 Grid/Solution.ts" @@ -0,0 +1,14 @@ +function numOfWays(n: number): number { + const mod: number = 10 ** 9 + 7; + let f0: number = 6; + let f1: number = 6; + + for (let i = 1; i < n; i++) { + const g0: number = (3 * f0 + 2 * f1) % mod; + const g1: number = (2 * f0 + 2 * f1) % mod; + f0 = g0; + f1 = g1; + } + + return (f0 + f1) % mod; +} diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README.md b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README.md index 879eaea0f921c..e06cb05277232 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README.md +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README.md @@ -122,9 +122,11 @@ class Solution { final int mod = (int) 1e9 + 7; int mx = (int) Math.pow(3, m); Set valid = new HashSet<>(); + int[] f = new int[mx]; for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } Map> d = new HashMap<>(); @@ -135,10 +137,6 @@ class Solution { } } } - int[] f = new int[mx]; - for (int i = 0; i < mx; ++i) { - f[i] = valid.contains(i) ? 1 : 0; - } for (int k = 1; k < n; ++k) { int[] g = new int[mx]; for (int i : valid) { @@ -211,9 +209,11 @@ public: const int mod = 1e9 + 7; int mx = pow(3, m); unordered_set valid; + vector f(mx); for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.insert(i); + f[i] = 1; } } unordered_map> d; @@ -224,10 +224,6 @@ public: } } } - vector f(mx); - for (int i = 0; i < mx; ++i) { - f[i] = valid.count(i); - } for (int k = 1; k < n; ++k) { vector g(mx); for (int i : valid) { @@ -273,9 +269,11 @@ func colorTheGrid(m int, n int) (ans int) { } mx := int(math.Pow(3, float64(m))) valid := map[int]bool{} + f := make([]int, mx) for i := 0; i < mx; i++ { if f1(i) { valid[i] = true + f[i] = 1 } } d := map[int][]int{} @@ -286,12 +284,6 @@ func colorTheGrid(m int, n int) (ans int) { } } } - f := make([]int, mx) - for i := 0; i < mx; i++ { - if valid[i] { - f[i] = 1 - } - } const mod int = 1e9 + 7 for k := 1; k < n; k++ { g := make([]int, mx) @@ -336,9 +328,11 @@ function colorTheGrid(m: number, n: number): number { }; const mx = 3 ** m; const valid = new Set(); + const f: number[] = Array(mx).fill(0); for (let i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } const d: Map = new Map(); @@ -349,12 +343,6 @@ function colorTheGrid(m: number, n: number): number { } } } - const f: number[] = Array(mx).fill(0); - for (let i = 0; i < mx; ++i) { - if (valid.has(i)) { - f[i] = 1; - } - } const mod = 10 ** 9 + 7; for (let k = 1; k < n; ++k) { const g: number[] = Array(mx).fill(0); diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README_EN.md b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README_EN.md index d0448cf1c28d5..a4758bc614cfb 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README_EN.md +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/README_EN.md @@ -112,9 +112,11 @@ class Solution { final int mod = (int) 1e9 + 7; int mx = (int) Math.pow(3, m); Set valid = new HashSet<>(); + int[] f = new int[mx]; for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } Map> d = new HashMap<>(); @@ -125,10 +127,6 @@ class Solution { } } } - int[] f = new int[mx]; - for (int i = 0; i < mx; ++i) { - f[i] = valid.contains(i) ? 1 : 0; - } for (int k = 1; k < n; ++k) { int[] g = new int[mx]; for (int i : valid) { @@ -201,9 +199,11 @@ public: const int mod = 1e9 + 7; int mx = pow(3, m); unordered_set valid; + vector f(mx); for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.insert(i); + f[i] = 1; } } unordered_map> d; @@ -214,10 +214,6 @@ public: } } } - vector f(mx); - for (int i = 0; i < mx; ++i) { - f[i] = valid.count(i); - } for (int k = 1; k < n; ++k) { vector g(mx); for (int i : valid) { @@ -263,9 +259,11 @@ func colorTheGrid(m int, n int) (ans int) { } mx := int(math.Pow(3, float64(m))) valid := map[int]bool{} + f := make([]int, mx) for i := 0; i < mx; i++ { if f1(i) { valid[i] = true + f[i] = 1 } } d := map[int][]int{} @@ -276,12 +274,6 @@ func colorTheGrid(m int, n int) (ans int) { } } } - f := make([]int, mx) - for i := 0; i < mx; i++ { - if valid[i] { - f[i] = 1 - } - } const mod int = 1e9 + 7 for k := 1; k < n; k++ { g := make([]int, mx) @@ -326,9 +318,11 @@ function colorTheGrid(m: number, n: number): number { }; const mx = 3 ** m; const valid = new Set(); + const f: number[] = Array(mx).fill(0); for (let i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } const d: Map = new Map(); @@ -339,12 +333,6 @@ function colorTheGrid(m: number, n: number): number { } } } - const f: number[] = Array(mx).fill(0); - for (let i = 0; i < mx; ++i) { - if (valid.has(i)) { - f[i] = 1; - } - } const mod = 10 ** 9 + 7; for (let k = 1; k < n; ++k) { const g: number[] = Array(mx).fill(0); diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.cpp b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.cpp index 8ade9b1ab5a1e..64987328a2b99 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.cpp +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.cpp @@ -26,9 +26,11 @@ class Solution { const int mod = 1e9 + 7; int mx = pow(3, m); unordered_set valid; + vector f(mx); for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.insert(i); + f[i] = 1; } } unordered_map> d; @@ -39,10 +41,6 @@ class Solution { } } } - vector f(mx); - for (int i = 0; i < mx; ++i) { - f[i] = valid.count(i); - } for (int k = 1; k < n; ++k) { vector g(mx); for (int i : valid) { diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.go b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.go index 3c7da525b45d9..ea56bde82fbf9 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.go +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.go @@ -22,9 +22,11 @@ func colorTheGrid(m int, n int) (ans int) { } mx := int(math.Pow(3, float64(m))) valid := map[int]bool{} + f := make([]int, mx) for i := 0; i < mx; i++ { if f1(i) { valid[i] = true + f[i] = 1 } } d := map[int][]int{} @@ -35,12 +37,6 @@ func colorTheGrid(m int, n int) (ans int) { } } } - f := make([]int, mx) - for i := 0; i < mx; i++ { - if valid[i] { - f[i] = 1 - } - } const mod int = 1e9 + 7 for k := 1; k < n; k++ { g := make([]int, mx) diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.java b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.java index 0798bd30f5c83..1aa965cd8c09a 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.java +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.java @@ -6,9 +6,11 @@ public int colorTheGrid(int m, int n) { final int mod = (int) 1e9 + 7; int mx = (int) Math.pow(3, m); Set valid = new HashSet<>(); + int[] f = new int[mx]; for (int i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } Map> d = new HashMap<>(); @@ -19,10 +21,6 @@ public int colorTheGrid(int m, int n) { } } } - int[] f = new int[mx]; - for (int i = 0; i < mx; ++i) { - f[i] = valid.contains(i) ? 1 : 0; - } for (int k = 1; k < n; ++k) { int[] g = new int[mx]; for (int i : valid) { diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.ts b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.ts index 299e7bdf2747d..c8f5fc34c30d8 100644 --- a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.ts +++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.ts @@ -22,9 +22,11 @@ function colorTheGrid(m: number, n: number): number { }; const mx = 3 ** m; const valid = new Set(); + const f: number[] = Array(mx).fill(0); for (let i = 0; i < mx; ++i) { if (f1(i)) { valid.add(i); + f[i] = 1; } } const d: Map = new Map(); @@ -35,12 +37,6 @@ function colorTheGrid(m: number, n: number): number { } } } - const f: number[] = Array(mx).fill(0); - for (let i = 0; i < mx; ++i) { - if (valid.has(i)) { - f[i] = 1; - } - } const mod = 10 ** 9 + 7; for (let k = 1; k < n; ++k) { const g: number[] = Array(mx).fill(0);