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 71ff197a8e287..879eaea0f921c 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	
@@ -48,6 +48,24 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：状态压缩 + 动态规划**
+
+我们注意到，网格的行数不超过 $5$，那么一列中最多有 $3^5=243$ 种不同的颜色方案。
+
+因此，我们定义 $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)$。其中 $m$ 和 $n$ 分别是网格的行数和列数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -55,7 +73,40 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def colorTheGrid(self, m: int, n: int) -> int:
+        def f1(x: int) -> bool:
+            last = -1
+            for _ in range(m):
+                if x % 3 == last:
+                    return False
+                last = x % 3
+                x //= 3
+            return True
+
+        def f2(x: int, y: int) -> bool:
+            for _ in range(m):
+                if x % 3 == y % 3:
+                    return False
+                x, y = x // 3, y // 3
+            return True
 
+        mod = 10**9 + 7
+        mx = 3**m
+        valid = {i for i in range(mx) if f1(i)}
+        d = defaultdict(list)
+        for x in valid:
+            for y in valid:
+                if f2(x, y):
+                    d[x].append(y)
+        f = [int(i in valid) for i in range(mx)]
+        for _ in range(n - 1):
+            g = [0] * mx
+            for i in valid:
+                for j in d[i]:
+                    g[i] = (g[i] + f[j]) % mod
+            f = g
+        return sum(f) % mod
 ```
 
 ### **Java**
@@ -63,7 +114,263 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int m;
+
+    public int colorTheGrid(int m, int n) {
+        this.m = m;
+        final int mod = (int) 1e9 + 7;
+        int mx = (int) Math.pow(3, m);
+        Set<Integer> valid = new HashSet<>();
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.add(i);
+            }
+        }
+        Map<Integer, List<Integer>> d = new HashMap<>();
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                }
+            }
+        }
+        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) {
+                for (int j : d.getOrDefault(i, List.of())) {
+                    g[i] = (g[i] + f[j]) % 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 < m; ++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 < m; ++i) {
+            if (x % 3 == y % 3) {
+                return false;
+            }
+            x /= 3;
+            y /= 3;
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int colorTheGrid(int m, int n) {
+        auto f1 = [&](int x) {
+            int last = -1;
+            for (int i = 0; i < m; ++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 < m; ++i) {
+                if (x % 3 == y % 3) {
+                    return false;
+                }
+                x /= 3;
+                y /= 3;
+            }
+            return true;
+        };
+
+        const int mod = 1e9 + 7;
+        int mx = pow(3, m);
+        unordered_set<int> valid;
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.insert(i);
+            }
+        }
+        unordered_map<int, vector<int>> d;
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d[i].push_back(j);
+                }
+            }
+        }
+        vector<int> f(mx);
+        for (int i = 0; i < mx; ++i) {
+            f[i] = valid.count(i);
+        }
+        for (int k = 1; k < n; ++k) {
+            vector<int> g(mx);
+            for (int i : valid) {
+                for (int j : d[i]) {
+                    g[i] = (g[i] + f[j]) % mod;
+                }
+            }
+            f = move(g);
+        }
+        int ans = 0;
+        for (int x : f) {
+            ans = (ans + x) % mod;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func colorTheGrid(m int, n int) (ans int) {
+	f1 := func(x int) bool {
+		last := -1
+		for i := 0; i < m; i++ {
+			if x%3 == last {
+				return false
+			}
+			last = x % 3
+			x /= 3
+		}
+		return true
+	}
+	f2 := func(x, y int) bool {
+		for i := 0; i < m; i++ {
+			if x%3 == y%3 {
+				return false
+			}
+			x /= 3
+			y /= 3
+		}
+		return true
+	}
+	mx := int(math.Pow(3, float64(m)))
+	valid := map[int]bool{}
+	for i := 0; i < mx; i++ {
+		if f1(i) {
+			valid[i] = true
+		}
+	}
+	d := map[int][]int{}
+	for i := range valid {
+		for j := range valid {
+			if f2(i, j) {
+				d[i] = append(d[i], j)
+			}
+		}
+	}
+	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)
+		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 colorTheGrid(m: number, n: number): number {
+    const f1 = (x: number): boolean => {
+        let last = -1;
+        for (let i = 0; i < m; ++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 < m; ++i) {
+            if (x % 3 === y % 3) {
+                return false;
+            }
+            x = Math.floor(x / 3);
+            y = Math.floor(y / 3);
+        }
+        return true;
+    };
+    const mx = 3 ** m;
+    const valid = new Set<number>();
+    for (let i = 0; i < mx; ++i) {
+        if (f1(i)) {
+            valid.add(i);
+        }
+    }
+    const d: Map<number, number[]> = 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 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);
+        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/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 123fd90d3fdde..d0448cf1c28d5 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	
@@ -42,18 +42,325 @@
 
 ## Solutions
 
+**Solution 1: State Compression + Dynamic Programming**
+
+We notice that the number of rows in the grid does not exceed $5$, so there are at most $3^5=243$ different color schemes in a column.
+
+Therefore, we define $f[i][j]$ to represent the number of schemes in the first $i$ columns, where the coloring state of the $i$th column 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 column, 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.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
+class Solution:
+    def colorTheGrid(self, m: int, n: int) -> int:
+        def f1(x: int) -> bool:
+            last = -1
+            for _ in range(m):
+                if x % 3 == last:
+                    return False
+                last = x % 3
+                x //= 3
+            return True
+
+        def f2(x: int, y: int) -> bool:
+            for _ in range(m):
+                if x % 3 == y % 3:
+                    return False
+                x, y = x // 3, y // 3
+            return True
 
+        mod = 10**9 + 7
+        mx = 3**m
+        valid = {i for i in range(mx) if f1(i)}
+        d = defaultdict(list)
+        for x in valid:
+            for y in valid:
+                if f2(x, y):
+                    d[x].append(y)
+        f = [int(i in valid) for i in range(mx)]
+        for _ in range(n - 1):
+            g = [0] * mx
+            for i in valid:
+                for j in d[i]:
+                    g[i] = (g[i] + f[j]) % mod
+            f = g
+        return sum(f) % mod
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private int m;
+
+    public int colorTheGrid(int m, int n) {
+        this.m = m;
+        final int mod = (int) 1e9 + 7;
+        int mx = (int) Math.pow(3, m);
+        Set<Integer> valid = new HashSet<>();
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.add(i);
+            }
+        }
+        Map<Integer, List<Integer>> d = new HashMap<>();
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                }
+            }
+        }
+        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) {
+                for (int j : d.getOrDefault(i, List.of())) {
+                    g[i] = (g[i] + f[j]) % 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 < m; ++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 < m; ++i) {
+            if (x % 3 == y % 3) {
+                return false;
+            }
+            x /= 3;
+            y /= 3;
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int colorTheGrid(int m, int n) {
+        auto f1 = [&](int x) {
+            int last = -1;
+            for (int i = 0; i < m; ++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 < m; ++i) {
+                if (x % 3 == y % 3) {
+                    return false;
+                }
+                x /= 3;
+                y /= 3;
+            }
+            return true;
+        };
+
+        const int mod = 1e9 + 7;
+        int mx = pow(3, m);
+        unordered_set<int> valid;
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.insert(i);
+            }
+        }
+        unordered_map<int, vector<int>> d;
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d[i].push_back(j);
+                }
+            }
+        }
+        vector<int> f(mx);
+        for (int i = 0; i < mx; ++i) {
+            f[i] = valid.count(i);
+        }
+        for (int k = 1; k < n; ++k) {
+            vector<int> g(mx);
+            for (int i : valid) {
+                for (int j : d[i]) {
+                    g[i] = (g[i] + f[j]) % mod;
+                }
+            }
+            f = move(g);
+        }
+        int ans = 0;
+        for (int x : f) {
+            ans = (ans + x) % mod;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func colorTheGrid(m int, n int) (ans int) {
+	f1 := func(x int) bool {
+		last := -1
+		for i := 0; i < m; i++ {
+			if x%3 == last {
+				return false
+			}
+			last = x % 3
+			x /= 3
+		}
+		return true
+	}
+	f2 := func(x, y int) bool {
+		for i := 0; i < m; i++ {
+			if x%3 == y%3 {
+				return false
+			}
+			x /= 3
+			y /= 3
+		}
+		return true
+	}
+	mx := int(math.Pow(3, float64(m)))
+	valid := map[int]bool{}
+	for i := 0; i < mx; i++ {
+		if f1(i) {
+			valid[i] = true
+		}
+	}
+	d := map[int][]int{}
+	for i := range valid {
+		for j := range valid {
+			if f2(i, j) {
+				d[i] = append(d[i], j)
+			}
+		}
+	}
+	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)
+		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 colorTheGrid(m: number, n: number): number {
+    const f1 = (x: number): boolean => {
+        let last = -1;
+        for (let i = 0; i < m; ++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 < m; ++i) {
+            if (x % 3 === y % 3) {
+                return false;
+            }
+            x = Math.floor(x / 3);
+            y = Math.floor(y / 3);
+        }
+        return true;
+    };
+    const mx = 3 ** m;
+    const valid = new Set<number>();
+    for (let i = 0; i < mx; ++i) {
+        if (f1(i)) {
+            valid.add(i);
+        }
+    }
+    const d: Map<number, number[]> = 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 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);
+        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/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
new file mode 100644
index 0000000000000..8ade9b1ab5a1e
--- /dev/null
+++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.cpp	
@@ -0,0 +1,61 @@
+class Solution {
+public:
+    int colorTheGrid(int m, int n) {
+        auto f1 = [&](int x) {
+            int last = -1;
+            for (int i = 0; i < m; ++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 < m; ++i) {
+                if (x % 3 == y % 3) {
+                    return false;
+                }
+                x /= 3;
+                y /= 3;
+            }
+            return true;
+        };
+
+        const int mod = 1e9 + 7;
+        int mx = pow(3, m);
+        unordered_set<int> valid;
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.insert(i);
+            }
+        }
+        unordered_map<int, vector<int>> d;
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d[i].push_back(j);
+                }
+            }
+        }
+        vector<int> f(mx);
+        for (int i = 0; i < mx; ++i) {
+            f[i] = valid.count(i);
+        }
+        for (int k = 1; k < n; ++k) {
+            vector<int> g(mx);
+            for (int i : valid) {
+                for (int j : d[i]) {
+                    g[i] = (g[i] + f[j]) % mod;
+                }
+            }
+            f = move(g);
+        }
+        int ans = 0;
+        for (int x : f) {
+            ans = (ans + x) % mod;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
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
new file mode 100644
index 0000000000000..3c7da525b45d9
--- /dev/null
+++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.go	
@@ -0,0 +1,58 @@
+func colorTheGrid(m int, n int) (ans int) {
+	f1 := func(x int) bool {
+		last := -1
+		for i := 0; i < m; i++ {
+			if x%3 == last {
+				return false
+			}
+			last = x % 3
+			x /= 3
+		}
+		return true
+	}
+	f2 := func(x, y int) bool {
+		for i := 0; i < m; i++ {
+			if x%3 == y%3 {
+				return false
+			}
+			x /= 3
+			y /= 3
+		}
+		return true
+	}
+	mx := int(math.Pow(3, float64(m)))
+	valid := map[int]bool{}
+	for i := 0; i < mx; i++ {
+		if f1(i) {
+			valid[i] = true
+		}
+	}
+	d := map[int][]int{}
+	for i := range valid {
+		for j := range valid {
+			if f2(i, j) {
+				d[i] = append(d[i], j)
+			}
+		}
+	}
+	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)
+		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
+}
\ No newline at end of file
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
new file mode 100644
index 0000000000000..0798bd30f5c83
--- /dev/null
+++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.java	
@@ -0,0 +1,64 @@
+class Solution {
+    private int m;
+
+    public int colorTheGrid(int m, int n) {
+        this.m = m;
+        final int mod = (int) 1e9 + 7;
+        int mx = (int) Math.pow(3, m);
+        Set<Integer> valid = new HashSet<>();
+        for (int i = 0; i < mx; ++i) {
+            if (f1(i)) {
+                valid.add(i);
+            }
+        }
+        Map<Integer, List<Integer>> d = new HashMap<>();
+        for (int i : valid) {
+            for (int j : valid) {
+                if (f2(i, j)) {
+                    d.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                }
+            }
+        }
+        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) {
+                for (int j : d.getOrDefault(i, List.of())) {
+                    g[i] = (g[i] + f[j]) % 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 < m; ++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 < m; ++i) {
+            if (x % 3 == y % 3) {
+                return false;
+            }
+            x /= 3;
+            y /= 3;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.py b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.py
new file mode 100644
index 0000000000000..a48a7114ac661
--- /dev/null
+++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.py	
@@ -0,0 +1,34 @@
+class Solution:
+    def colorTheGrid(self, m: int, n: int) -> int:
+        def f1(x: int) -> bool:
+            last = -1
+            for _ in range(m):
+                if x % 3 == last:
+                    return False
+                last = x % 3
+                x //= 3
+            return True
+
+        def f2(x: int, y: int) -> bool:
+            for _ in range(m):
+                if x % 3 == y % 3:
+                    return False
+                x, y = x // 3, y // 3
+            return True
+
+        mod = 10**9 + 7
+        mx = 3**m
+        valid = {i for i in range(mx) if f1(i)}
+        d = defaultdict(list)
+        for x in valid:
+            for y in valid:
+                if f2(x, y):
+                    d[x].append(y)
+        f = [int(i in valid) for i in range(mx)]
+        for _ in range(n - 1):
+            g = [0] * mx
+            for i in valid:
+                for j in d[i]:
+                    g[i] = (g[i] + f[j]) % mod
+            f = g
+        return sum(f) % mod
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
new file mode 100644
index 0000000000000..299e7bdf2747d
--- /dev/null
+++ b/solution/1900-1999/1931.Painting a Grid With Three Different Colors/Solution.ts	
@@ -0,0 +1,59 @@
+function colorTheGrid(m: number, n: number): number {
+    const f1 = (x: number): boolean => {
+        let last = -1;
+        for (let i = 0; i < m; ++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 < m; ++i) {
+            if (x % 3 === y % 3) {
+                return false;
+            }
+            x = Math.floor(x / 3);
+            y = Math.floor(y / 3);
+        }
+        return true;
+    };
+    const mx = 3 ** m;
+    const valid = new Set<number>();
+    for (let i = 0; i < mx; ++i) {
+        if (f1(i)) {
+            valid.add(i);
+        }
+    }
+    const d: Map<number, number[]> = 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 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);
+        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;
+}