From 11a7d6775d1beafdf6a46785bf69f22f3337a0ff Mon Sep 17 00:00:00 2001
From: li_chx <li_chx@qq.com>
Date: Tue, 21 Apr 2026 15:00:19 +0800
Subject: [PATCH] =?UTF-8?q?1722.=20=E6=89=A7=E8=A1=8C=E4=BA=A4=E6=8D=A2?=
 =?UTF-8?q?=E6=93=8D=E4=BD=9C=E5=90=8E=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B1=89?=
 =?UTF-8?q?=E6=98=8E=E8=B7=9D=E7=A6=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main.rs | 86 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 50 insertions(+), 36 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index b119f42..f845ca4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,51 +1,65 @@
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
+use crate::arr::make_matrix;
+
+use std::collections::{HashMap, HashSet, VecDeque};
 
 mod arr;
 
 struct Solution {}
 impl Solution {
-    fn get_rev(t: i32) -> i32 {
-        let mut t = t;
+    pub fn minimum_hamming_distance(
+        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 {
-            ans = ans * 10 + (t % 10);
-            t /= 10;
-        }
-        ans
-    }
-    pub fn min_mirror_pair_distance(nums: Vec<i32>) -> i32 {
-        let mut map = HashMap::<i32, Vec<usize>>::new();
-        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);
-                        }
+        let get_all_ele = |st : &HashSet<i32>| -> HashSet<i32> {
+            let mut visited = HashSet::<i32>::new();
+            let mut stack = st.iter().copied().collect::<VecDeque<i32>>();
+            while let Some(cur) = stack.pop_front() {
+                visited.insert(cur);
+                for &nxt in map.get(&cur).unwrap_or(&HashSet::new()) {
+                    if !visited.contains(&nxt) {
+                        stack.push_back(nxt);
                     }
                 }
-                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]]"))
+    );
 }