1722. 执行交换操作后的最小汉明距离

src/main.rs

@@ -1,51 +1,65 @@
-use std::collections::HashMap;
+use crate::arr::make_matrix;
-use std::collections::hash_map::Entry;
+
+use std::collections::{HashMap, HashSet, VecDeque};
 
 mod arr;
 
 struct Solution {}
 impl Solution {
-    fn get_rev(t: i32) -> i32 {
+    pub fn minimum_hamming_distance(
-        let mut t = t;
+        source: Vec<i32>,
+        target: Vec<i32>,
+        allowed_swaps: Vec<Vec<i32>>,
+    ) -> i32 {
+        let mut map = HashMap::<i32, HashSet<i32>>::new();
+        let mut index = vec![0; target.len()];
+        for swp in &allowed_swaps {
+            let (a, b) = (swp[0], swp[1]);
+            map.entry(a).or_insert_with(HashSet::new).insert(b);
+            map.entry(b).or_insert_with(HashSet::new).insert(a);
+        }
         let mut ans = 0;
-        while t > 0 {
+        let get_all_ele = |st : &HashSet<i32>| -> HashSet<i32> {
-            ans = ans * 10 + (t % 10);
+            let mut visited = HashSet::<i32>::new();
-            t /= 10;
+            let mut stack = st.iter().copied().collect::<VecDeque<i32>>();
-        }
+            while let Some(cur) = stack.pop_front() {
-        ans
+                visited.insert(cur);
-    }
+                for &nxt in map.get(&cur).unwrap_or(&HashSet::new()) {
-    pub fn min_mirror_pair_distance(nums: Vec<i32>) -> i32 {
+                    if !visited.contains(&nxt) {
-        let mut map = HashMap::<i32, Vec<usize>>::new();
+                        stack.push_back(nxt);
-        for i in 0..nums.len() {
-            map.entry(nums[i]).or_insert_with(Vec::new).push(i);
-        }
-        let mut ans = 1e9 as usize;
-        for i in 0..nums.len() {
-            let x = nums[i];
-            match map.entry(Self::get_rev(x)) {
-                Entry::Occupied(arr) => {
-                    //ans = ans.max(i.abs_diff(*arr.get().last().unwrap())).max(i.abs_diff(*arr.get().first().unwrap()));
-                    let arr = arr.get();
-                    if arr.len() == 1 {
-                        if i != arr[0] && arr[0] > i {
-                            ans = ans.min(arr[0] - i);
-                        }
-                        continue;
-                    }
-                    let idx = arr.partition_point(|y| i >= *y);
-                    if idx < arr.len() {
-                        if i != arr[idx] {
-                            ans = ans.min(arr[idx] - i);
-                        }
                     }
                 }
-                Entry::Vacant(_) => {}
             }
+            visited
+        };
+        for i in 0..source.len() {
+            if index[i] == -1 {
+                continue;
+            }
+            if map.contains_key(&(i as i32)) {
+                let mut src_map = HashMap::<i32, i32>::new();
+                let mut target_map = HashMap::<i32, i32>::new();
+                for t in get_all_ele(map.get(&(i as i32)).unwrap()) {
+                    *src_map.entry(source[t as usize]).or_insert(0) += 1;
+                    *target_map.entry(target[t as usize]).or_insert(0) += 1;
+                    index[t as usize] = -1;
+                }
+                let mut local_ans = 0;
+                for (k, v) in target_map {
+                    local_ans += (v - *src_map.get(&k).unwrap_or(&0)).max(0);
+                }
+                ans += local_ans;
+                continue;
+            }
+            ans += if source[i] == target[i] { 0 } else { 1 };
         }
-        if ans == 1e9 as usize { -1 } else { ans as i32 }
+        ans
     }
 }
 
 fn main() {
-    println!("{:?}", Solution::min_mirror_pair_distance(vec![9,9]));
+    println!(
+        "{:?}",
+        Solution::minimum_hamming_distance(vec![18,42,18,64], vec![61,94,18,44], make_matrix("[[2,3],[0,1],[3,1]]"))
+    );
 }