Similar string groups

/*
 * Two strings, X and Y, are considered similar if either they are identical or we can make them equivalent by swapping at most two letters (in distinct positions) within the string X.
 * For example, "tars" and "rats" are similar (swapping at positions 0 and 2), and "rats" and "arts" are similar, but "star" is not similar to "tars", "rats", or "arts".
 * Together, these form two connected groups by similarity: {"tars", "rats", "arts"} and {"star"}.  Notice that "tars" and "arts" are in the same group even though they are not similar.  Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.
 * We are given a list strs of strings where every string in strs is an anagram of every other string in strs. How many groups are there?
 * Example 1:
 * Input: strs = ["tars","rats","arts","star"]
 * Output: 2
 * Example 2:
 * Input: strs = ["omv","ovm"]
 * Output: 1
 * Constraints:
 * 1 <= strs.length <= 300
 * 1 <= strs[i].length <= 300
 * strs[i] consists of lowercase letters only.
 * All words in strs have the same length and are anagrams of each other.
 */

impl Solution {
  pub fn num_similar_groups(strs: Vec<String>) -> i32 {
    let n = strs.len();
    let mut parent: Vec<usize> = (0..n).collect();
    fn find(parent: &mut Vec<usize>, x: usize) -> usize {
      if parent[x] != x { parent[x] = find(parent, parent[x]); }
      parent[x]
    }
    fn similar(a: &[u8], b: &[u8]) -> bool {
      let diffs: Vec<usize> = (0..a.len()).filter(|&i| a[i] != b[i]).collect();
      diffs.len() == 0 || (diffs.len() == 2 && a[diffs[0]] == b[diffs[1]] && a[diffs[1]] == b[diffs[0]])
    }
    for i in 0..n {
      for j in i+1..n {
        if similar(strs[i].as_bytes(), strs[j].as_bytes()) {
          let pi = find(&mut parent, i);
          let pj = find(&mut parent, j);
          if pi != pj { parent[pi] = pj; }
        }
      }
    }
    (0..n).filter(|&i| find(&mut parent, i) == i).count() as i32
  }
}