1590. 使数组和能被 P 整除

src/main.rs

@@ -1,44 +1,37 @@
-use crate::arr::make_matrix;
-use std::collections::HashSet;
+use std::cmp::min;
+use std::collections::HashMap;
 
 struct Solution;
 mod arr;
 impl Solution {
-    pub fn max_k_divisible_components(
-        n: i32,
-        edges: Vec<Vec<i32>>,
-        values: Vec<i32>,
-        k: i32,
-    ) -> i32 {
-        let mut edge = vec![HashSet::new(); n as usize];
-        edges.iter().for_each(|x| {
-            edge[x[0] as usize].insert(x[1] as usize);
-            edge[x[1] as usize].insert(x[0] as usize);
-        });
-        fn dfs(total_ans:&mut i32, k:i32, root: usize, last: usize, edge: &Vec<HashSet<usize>>,values: &Vec<i32>) -> i64{
-            let mut ans = values[root] as i64;
-            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
-            }
+    pub fn min_subarray(nums: Vec<i32>, p: i32) -> i32 {
+        let mut nums = nums;
+        let p = p as i64;
+        let mut arr = vec![0_i64; nums.len()];
+        arr[0] = nums[0] as i64;
+        for i in 1..arr.len() {
+            arr[i] = arr[i-1] + nums[i] as i64;
         }
-        let mut ans = 0;
-        dfs(&mut ans,k,0, usize::MAX, &edge,&values);
-        ans
+        let sum = arr[arr.len() - 1];
+        if sum % p== 0 {
+            return 0;
+        }
+        let get_right = |right_value: i64| -> i64 { ((right_value % p) - (sum % p) + p) % p };
+        let mut map: HashMap<i64, i32> = HashMap::new();
+        let mut ans = 1000000000;
+        // nums[right] - nums[left] ≡ sum (mod p)
+        // (nums[right] mod p  - sum mod p + p) mod ≡ nums[left] (mod p)
+        map.insert(0, -1);
+        for i in 0..arr.len() {
+            if let Some(v) = map.get(&get_right(arr[i])) {
+                ans = min(ans, i as i32 - v);
+            }
+            map.insert(arr[i] % p, i as i32);
+        }
+        if ans >= nums.len() as i32 { -1 } else { ans }
     }
 }
 fn main() {
-    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,
-    );
+    let result = Solution::min_subarray(vec![3,1,3], 3);
     println!("{:?}", result);
 }