feat: add solutions to lc problem: No.0326

No.0326.Power of Three

Author: yanglbme

solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/README.md

@@ -167,38 +167,34 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<int> p;
-
     int countComponents(int n, vector<vector<int>>& edges) {
-        p.resize(n);
+        vector<int> p(n);
+        iota(p.begin(), p.end(), 0);
         for (int i = 0; i < n; ++i) p[i] = i;
+        function<int(int)> find = [&](int x) -> int {
+            if (p[x] != x) p[x] = find(p[x]);
+            return p[x];
+        };
         for (auto& e : edges) {
             int a = e[0], b = e[1];
             p[find(a)] = find(b);
         }
         int ans = 0;
-        for (int i = 0; i < n; ++i)
-            if (i == find(i))
-                ++ans;
+        for (int i = 0; i < n; ++i) ans += i == find(i);
         return ans;
     }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
 };
 ```
 
 ### **Go**
 
 ```go
-func countComponents(n int, edges [][]int) int {
+func countComponents(n int, edges [][]int) (ans int) {
 	p := make([]int, n)
 	for i := range p {
 		p[i] = i
 	}
-	var find func(x int) int
+	var find func(int) int
 	find = func(x int) int {
 		if p[x] != x {
 			p[x] = find(p[x])
@@ -209,13 +205,12 @@ func countComponents(n int, edges [][]int) int {
 		a, b := e[0], e[1]
 		p[find(a)] = find(b)
 	}
-	ans := 0
 	for i := 0; i < n; i++ {
 		if i == find(i) {
 			ans++
 		}
 	}
-	return ans
+	return
 }
 ```
 

solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/README_EN.md

@@ -93,38 +93,34 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<int> p;
-
     int countComponents(int n, vector<vector<int>>& edges) {
-        p.resize(n);
+        vector<int> p(n);
+        iota(p.begin(), p.end(), 0);
         for (int i = 0; i < n; ++i) p[i] = i;
+        function<int(int)> find = [&](int x) -> int {
+            if (p[x] != x) p[x] = find(p[x]);
+            return p[x];
+        };
         for (auto& e : edges) {
             int a = e[0], b = e[1];
             p[find(a)] = find(b);
         }
         int ans = 0;
-        for (int i = 0; i < n; ++i)
-            if (i == find(i))
-                ++ans;
+        for (int i = 0; i < n; ++i) ans += i == find(i);
         return ans;
     }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
 };
 ```
 
 ### **Go**
 
 ```go
-func countComponents(n int, edges [][]int) int {
+func countComponents(n int, edges [][]int) (ans int) {
 	p := make([]int, n)
 	for i := range p {
 		p[i] = i
 	}
-	var find func(x int) int
+	var find func(int) int
 	find = func(x int) int {
 		if p[x] != x {
 			p[x] = find(p[x])
@@ -135,13 +131,12 @@ func countComponents(n int, edges [][]int) int {
 		a, b := e[0], e[1]
 		p[find(a)] = find(b)
 	}
-	ans := 0
 	for i := 0; i < n; i++ {
 		if i == find(i) {
 			ans++
 		}
 	}
-	return ans
+	return
 }
 ```
 

solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/Solution.cpp

@@ -1,23 +1,19 @@
 class Solution {
 public:
-    vector<int> p;
-
     int countComponents(int n, vector<vector<int>>& edges) {
-        p.resize(n);
+        vector<int> p(n);
+        iota(p.begin(), p.end(), 0);
         for (int i = 0; i < n; ++i) p[i] = i;
+        function<int(int)> find = [&](int x) -> int {
+            if (p[x] != x) p[x] = find(p[x]);
+            return p[x];
+        };
         for (auto& e : edges) {
             int a = e[0], b = e[1];
             p[find(a)] = find(b);
         }
         int ans = 0;
-        for (int i = 0; i < n; ++i)
-            if (i == find(i))
-                ++ans;
+        for (int i = 0; i < n; ++i) ans += i == find(i);
         return ans;
     }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
 };

solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/Solution.go

@@ -1,9 +1,9 @@
-func countComponents(n int, edges [][]int) int {
+func countComponents(n int, edges [][]int) (ans int) {
 	p := make([]int, n)
 	for i := range p {
 		p[i] = i
 	}
-	var find func(x int) int
+	var find func(int) int
 	find = func(x int) int {
 		if p[x] != x {
 			p[x] = find(p[x])
@@ -14,11 +14,10 @@ func countComponents(n int, edges [][]int) int {
 		a, b := e[0], e[1]
 		p[find(a)] = find(b)
 	}
-	ans := 0
 	for i := 0; i < n; i++ {
 		if i == find(i) {
 			ans++
 		}
 	}
-	return ans
+	return
 }

solution/0300-0399/0326.Power of Three/README.md

@@ -56,36 +56,132 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：试除法**
+
+如果 $n \gt 2$，我们可以不断地将 $n$ 除以 $3$，如果不能整除，说明 $n$ 不是 $3$ 的幂，否则继续除以 $3$，直到 $n$ 小于等于 $2$。如果 $n$ 等于 $1$，说明 $n$ 是 $3$ 的幂，否则不是 $3$ 的幂。
+
+时间复杂度 $O(\log_3n)$，空间复杂度 $O(1)$。
+
+**方法二：数学**
+
+如果 $n$ 是 $3$ 的幂，那么 $n$ 最大是 $3^{19} = 1162261467$，因此我们只需要判断 $n$ 是否是 $3^{19}$ 的约数即可。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def isPowerOfThree(self, n: int) -> bool:
+        while n > 2:
+            if n % 3:
+                return False
+            n //= 3
+        return n == 1
+```
 
+```python
+class Solution:
+    def isPowerOfThree(self, n: int) -> bool:
+        return n > 0 and 1162261467 % n == 0
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean isPowerOfThree(int n) {
+        while (n > 2) {
+            if (n % 3 != 0) {
+                return false;
+            }
+            n /= 3;
+        }
+        return n == 1;
+    }
+}
+```
+
+```java
+class Solution {
+    public boolean isPowerOfThree(int n) {
+        return n > 0 && 1162261467 % n == 0;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool isPowerOfThree(int n) {
+        while (n > 2) {
+            if (n % 3) {
+                return false;
+            }
+            n /= 3;
+        }
+        return n == 1;
+    }
+};
+```
 
+```cpp
+class Solution {
+public:
+    bool isPowerOfThree(int n) {
+        return n > 0 && 1162261467 % n == 0;
+    }
+};
+```
+
+### **Go**
+
+```go
+func isPowerOfThree(n int) bool {
+	for n > 2 {
+		if n%3 != 0 {
+			return false
+		}
+		n /= 3
+	}
+	return n == 1
+}
+```
+
+```go
+func isPowerOfThree(n int) bool {
+	return n > 0 && 1162261467%n == 0
+}
 ```
 
 ### **TypeScript**
 
 ```ts
 function isPowerOfThree(n: number): boolean {
-    while (n > 2) {
-        if (n % 3) return false;
-        n /= 3;
-    }
-    return n == 1;
+    return n > 0 && 1162261467 % n == 0;
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+var isPowerOfThree = function (n) {
+    return n > 0 && 1162261467 % n == 0;
+};
+```
+
 ### **...**
 
 ```