feat: add solutions to lc problem: No.0422

solution/0400-0499/0422.Valid Word Square/README.md

@@ -93,22 +93,119 @@ false
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：遍历检查**
+
+我们观察发现，只要不满足 $words[i][j] = words[j][i]$，就可以直接返回 `false`。
+
+因此，我们只需要遍历每一行，然后检查每一行是否满足 $words[i][j] = words[j][i]$ 即可。注意，如果下标越界，也直接返回 `false`。
+
+时间复杂度 $O(n^2)$，其中 $n$ 是 $words$ 的长度。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def validWordSquare(self, words: List[str]) -> bool:
+        m = len(words)
+        n = max(len(w) for w in words)
+        if m != n:
+            return False
+        for j in range(n):
+            if words[j] != "".join(w[j] for w in words if j < len(w)):
+                return False
+        return True
+```
 
+```python
+class Solution:
+    def validWordSquare(self, words: List[str]) -> bool:
+        m = len(words)
+        for i, w in enumerate(words):
+            for j, c in enumerate(w):
+                if j >= m or i >= len(words[j]) or c != words[j][i]:
+                    return False
+        return True
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean validWordSquare(List<String> words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words.get(i).length();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words.get(j).length()) {
+                    return false;
+                }
+                if (words.get(i).charAt(j) != words.get(j).charAt(i)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool validWordSquare(vector<string>& words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words[i].size();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words[j].size() || words[i][j] != words[j][i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+};
+```
+
+### **Go**
+
+```go
+func validWordSquare(words []string) bool {
+	m := len(words)
+	for i, w := range words {
+		for j := range w {
+			if j >= m || i >= len(words[j]) || w[j] != words[j][i] {
+				return false
+			}
+		}
+	}
+	return true
+}
+```
 
+### **TypeScript**
+
+```ts
+function validWordSquare(words: string[]): boolean {
+    const m = words.length;
+    for (let i = 0; i < m; ++i) {
+        const n = words[i].length;
+        for (let j = 0; j < n; ++j) {
+            if (j >= m || i >= words[j].length || words[i][j] !== words[j][i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 ```
 
 ### **...**

solution/0400-0499/0422.Valid Word Square/README_EN.md

@@ -61,13 +61,102 @@ Therefore, it is NOT a valid word square.
 ### **Python3**
 
 ```python
+class Solution:
+    def validWordSquare(self, words: List[str]) -> bool:
+        m = len(words)
+        n = max(len(w) for w in words)
+        if m != n:
+            return False
+        for j in range(n):
+            if words[j] != "".join(w[j] for w in words if j < len(w)):
+                return False
+        return True
+```
 
+```python
+class Solution:
+    def validWordSquare(self, words: List[str]) -> bool:
+        m = len(words)
+        for i, w in enumerate(words):
+            for j, c in enumerate(w):
+                if j >= m or i >= len(words[j]) or c != words[j][i]:
+                    return False
+        return True
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean validWordSquare(List<String> words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words.get(i).length();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words.get(j).length()) {
+                    return false;
+                }
+                if (words.get(i).charAt(j) != words.get(j).charAt(i)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool validWordSquare(vector<string>& words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words[i].size();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words[j].size() || words[i][j] != words[j][i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+};
+```
+
+### **Go**
+
+```go
+func validWordSquare(words []string) bool {
+	m := len(words)
+	for i, w := range words {
+		for j := range w {
+			if j >= m || i >= len(words[j]) || w[j] != words[j][i] {
+				return false
+			}
+		}
+	}
+	return true
+}
+```
 
+### **TypeScript**
+
+```ts
+function validWordSquare(words: string[]): boolean {
+    const m = words.length;
+    for (let i = 0; i < m; ++i) {
+        const n = words[i].length;
+        for (let j = 0; j < n; ++j) {
+            if (j >= m || i >= words[j].length || words[i][j] !== words[j][i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 ```
 
 ### **...**

solution/0400-0499/0422.Valid Word Square/Solution.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    bool validWordSquare(vector<string>& words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words[i].size();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words[j].size() || words[i][j] != words[j][i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+};

solution/0400-0499/0422.Valid Word Square/Solution.go

@@ -0,0 +1,11 @@
+func validWordSquare(words []string) bool {
+	m := len(words)
+	for i, w := range words {
+		for j := range w {
+			if j >= m || i >= len(words[j]) || w[j] != words[j][i] {
+				return false
+			}
+		}
+	}
+	return true
+}

solution/0400-0499/0422.Valid Word Square/Solution.java

@@ -0,0 +1,17 @@
+class Solution {
+    public boolean validWordSquare(List<String> words) {
+        int m = words.size();
+        for (int i = 0; i < m; ++i) {
+            int n = words.get(i).length();
+            for (int j = 0; j < n; ++j) {
+                if (j >= m || i >= words.get(j).length()) {
+                    return false;
+                }
+                if (words.get(i).charAt(j) != words.get(j).charAt(i)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

solution/0400-0499/0422.Valid Word Square/Solution.py

@@ -0,0 +1,8 @@
+class Solution:
+    def validWordSquare(self, words: List[str]) -> bool:
+        m = len(words)
+        for i, w in enumerate(words):
+            for j, c in enumerate(w):
+                if j >= m or i >= len(words[j]) or c != words[j][i]:
+                    return False
+        return True

solution/0400-0499/0422.Valid Word Square/Solution.ts

@@ -0,0 +1,12 @@
+function validWordSquare(words: string[]): boolean {
+    const m = words.length;
+    for (let i = 0; i < m; ++i) {
+        const n = words[i].length;
+        for (let j = 0; j < n; ++j) {
+            if (j >= m || i >= words[j].length || words[i][j] !== words[j][i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}