2872. 可以被 K 整除连通块的最大数目

src/main.rs

@@ -1,27 +1,44 @@
-use std::cmp::max;
+use crate::arr::make_matrix;
+use std::collections::HashSet;
 
 struct Solution;
 mod arr;
 impl Solution {
-    pub fn max_subarray_sum(nums: Vec<i32>, k: i32) -> i64 {
+    pub fn max_k_divisible_components(
-        let mut temp = 0_i64;
+        n: i32,
-        let k = k as usize;
+        edges: Vec<Vec<i32>>,
-        let mut dp = vec![0_i64; nums.len()];
+        values: Vec<i32>,
-        let mut ans = 0_i64;
+        k: i32,
-        for i in 0..k {
+    ) -> i32 {
-            temp += nums[i] as i64;
+        let mut edge = vec![HashSet::new(); n as usize];
-        }
+        edges.iter().for_each(|x| {
-        dp[k - 1] = temp;
+            edge[x[0] as usize].insert(x[1] as usize);
-        ans = temp;
+            edge[x[1] as usize].insert(x[0] as usize);
-        for i in k..nums.len() {
+        });
-            temp = temp + (nums[i] - nums[i - k]) as i64;
+        fn dfs(total_ans:&mut i32, k:i32, root: usize, last: usize, edge: &Vec<HashSet<usize>>,values: &Vec<i32>) -> i64{
-            dp[i] = temp + if dp[i-k] > 0 { dp[i-k] } else { 0 };
+            let mut ans = values[root] as i64;
-            ans = max(ans,dp[i]);
+            for &t in edge[root].iter() {
+                if t == last { continue; }
+                ans += dfs(total_ans,k,t, root, edge,values);
+            }
+            if ans % k as i64 == 0 {
+                *total_ans += 1;
+                0
+            }else {
+                ans
+            }
         }
+        let mut ans = 0;
+        dfs(&mut ans,k,0, usize::MAX, &edge,&values);
         ans
     }
 }
 fn main() {
-    let result = Solution::max_subarray_sum(vec![-5,1,2,-3,4],2);
+    let result = Solution::max_k_divisible_components(
+        7,
+        make_matrix("[[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]"),
+        vec![3, 0, 6, 1, 5, 2, 1],
+        3,
+    );
     println!("{:?}", result);
 }