Similar String Groups

Two strings X and Y are similar if we can swap two letters (in different positions) of X, so that it equals Y.

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 A of strings.  Every string in A is an anagram of every other string in A.  How many groups are there?

Example 1:

Input: ["tars","rats","arts","star"]
Output: 2
分析：
因为这个是找group，所以容易联想到用union-find.这里我们在确定谁是root的时候，总是挑index大的，这样才能把不同的groups合并成一个group.

 public class Solution {
     public int numSimilarGroups(String[] A) {
         int[] roots = new int[A.length];
         for (int i = ; i < A.length; i++) {
             roots[i] = i;
         }
         for (int i = ; i < A.length; i++) {
             for (int j = ; j < i; j++) {
                 if (similar(A[i], A[j])) {
                     roots[find(roots, j)] = i;
                 }
             }
         }
         int result = ;
         for (int i = ; i < roots.length; i++) {
             if (roots[i] == i) {
                 result++;
             }
         }
         return result;
     }
     private int find(int[] roots, int id) {
         while (roots[id] != id) {
             roots[id] = roots[roots[id]]; // path compression
             id = roots[id];
         }
         return id;
     }
     private boolean similar(String a, String b) {
         int res = , i = ;
         boolean consecutive = false;
         while (res <=  && i < a.length()){
             if (a.charAt(i) != b.charAt(i)) {
                 res++;
             }
             if (i >  && a.charAt(i) == a.charAt(i - )) {
                 consecutive = true;
             }
             i++;
         }
         return res ==  || res ==  && consecutive;
     }
 }