feat: add solutions for lc No.3910

Author: yanglbme

solution/3900-3999/3910.Count Connected Subgraphs with Even Node Sum/README.md

@@ -146,32 +146,226 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3900-3999/3910.Co
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：二进制枚举 + DFS
+
+我们注意到，题目中节点的数量不超过 $13$，因此我们可以枚举节点的所有非空子集 $s$，对于每个子集，我们可以计算出其节点值的总和，并判断其诱导子图是否连通。
+
+具体地，我们可以使用一个整数 $sub$ 来表示子集 $s$，其中 $sub$ 的第 $i$ 位为 $1$ 表示节点 $i$ 在子集中，为 $0$ 表示节点 $i$ 不在子集中。对于每个子集，我们首先计算出其节点值的总和，如果总和为奇数，则跳过该子集；否则，我们使用 DFS 来判断其诱导子图是否连通。我们可以使用一个整数 $vis$ 来表示已经访问过的节点，初始时 $vis$ 的第 $i$ 位为 $1$ 表示节点 $i$ 不在子集中，为 $0$ 表示节点 $i$ 在子集中。我们从子集 $s$ 中的任意一个节点开始 DFS，访问其所有相邻节点，并将访问过的节点在 $vis$ 中标记为 $1$。最后，如果 $vis$ 的所有位都为 $1$，则说明子集 $s$ 的诱导子图是连通的，我们将答案加 $1$。
+
+时间复杂度 $O(2^n \times (n + m))$，空间复杂度 $O(n + m)$，其中 $n$ 和 $m$ 分别是节点数和边数。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def evenSumSubgraphs(self, nums: list[int], edges: list[list[int]]) -> int:
+        n = len(nums)
+        g = [[] for _ in range(n)]
+        for u, v in edges:
+            g[u].append(v)
+            g[v].append(u)
+        m = (1 << n) - 1
+        ans = 0
+        for sub in range(1, m + 1):
+            s = sum(x for i, x in enumerate(nums) if sub >> i & 1)
+            if s % 2:
+                continue
+            vis = m ^ sub
+
+            def dfs(u: int) -> None:
+                nonlocal vis
+                vis |= 1 << u
+                for v in g[u]:
+                    if (vis >> v & 1) == 0:
+                        dfs(v)
+
+            dfs(sub.bit_length() - 1)
+            if vis == m:
+                ans += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private int vis;
+    private int m;
+    private List<Integer>[] g;
+
+    public int evenSumSubgraphs(int[] nums, int[][] edges) {
+        int n = nums.length;
+        g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (int[] e : edges) {
+            g[e[0]].add(e[1]);
+            g[e[1]].add(e[0]);
+        }
+        m = (1 << n) - 1;
+        int ans = 0;
+        for (int sub = 1; sub <= m; sub++) {
+            int s = 0;
+            for (int i = 0; i < n; i++) {
+                if (((sub >> i) & 1) == 1) {
+                    s += nums[i];
+                }
+            }
+            if (s % 2 != 0) {
+                continue;
+            }
+            vis = m ^ sub;
+            dfs(Integer.numberOfTrailingZeros(sub));
+            if (vis == m) {
+                ans++;
+            }
+        }
+        return ans;
+    }
+
+    private void dfs(int u) {
+        vis |= 1 << u;
+        for (int v : g[u]) {
+            if (((vis >> v) & 1) == 0) {
+                dfs(v);
+            }
+        }
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int evenSumSubgraphs(vector<int>& nums, vector<vector<int>>& edges) {
+        int n = nums.size();
+        vector<vector<int>> g(n);
+        for (auto& e : edges) {
+            g[e[0]].push_back(e[1]);
+            g[e[1]].push_back(e[0]);
+        }
+        int m = (1 << n) - 1;
+        int ans = 0;
+        int vis;
+
+        auto dfs = [&](this auto dfs, int u) -> void {
+            vis |= 1 << u;
+            for (int v : g[u]) {
+                if (((vis >> v) & 1) == 0) {
+                    dfs(v);
+                }
+            }
+        };
+
+        for (int sub = 1; sub <= m; sub++) {
+            int s = 0;
+            for (int i = 0; i < n; i++) {
+                if ((sub >> i) & 1) {
+                    s += nums[i];
+                }
+            }
+            if (s % 2 != 0) {
+                continue;
+            }
+            vis = m ^ sub;
+            dfs(31 - __builtin_clz(sub));
+            if (vis == m) {
+                ans++;
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func evenSumSubgraphs(nums []int, edges [][]int) int {
+	n := len(nums)
+	g := make([][]int, n)
+	for _, e := range edges {
+		g[e[0]] = append(g[e[0]], e[1])
+		g[e[1]] = append(g[e[1]], e[0])
+	}
+	m := (1 << n) - 1
+	ans := 0
+	var vis int
+
+	var dfs func(int)
+	dfs = func(u int) {
+		vis |= 1 << u
+		for _, v := range g[u] {
+			if (vis >> v & 1) == 0 {
+				dfs(v)
+			}
+		}
+	}
+
+	for sub := 1; sub <= m; sub++ {
+		s := 0
+		for i := 0; i < n; i++ {
+			if sub>>i&1 == 1 {
+				s += nums[i]
+			}
+		}
+		if s%2 != 0 {
+			continue
+		}
+		vis = m ^ sub
+		dfs(bits.Len(uint(sub)) - 1)
+		if vis == m {
+			ans++
+		}
+	}
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function evenSumSubgraphs(nums: number[], edges: number[][]): number {
+    const n = nums.length;
+    const g: number[][] = Array.from({ length: n }, () => []);
+    for (const [u, v] of edges) {
+        g[u].push(v);
+        g[v].push(u);
+    }
+    const m = (1 << n) - 1;
+    let ans = 0;
+    let vis = 0;
+
+    const dfs = (u: number): void => {
+        vis |= 1 << u;
+        for (const v of g[u]) {
+            if (((vis >> v) & 1) === 0) {
+                dfs(v);
+            }
+        }
+    };
+
+    for (let sub = 1; sub <= m; sub++) {
+        let s = 0;
+        for (let i = 0; i < n; i++) {
+            if ((sub >> i) & 1) {
+                s += nums[i];
+            }
+        }
+        if (s % 2 !== 0) {
+            continue;
+        }
+        vis = m ^ sub;
+        dfs(sub.toString(2).length - 1);
+        if (vis === m) {
+            ans++;
+        }
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->