【Leetcode】737. Sentence Similarity II

題目地址：

https://leetcode.com/problems/sentence-similarity-ii/

給定一個列表，列表中每個位置都是一個長爲$2$的字符串數組，規定數組內的字符串是”相似的“。再給定兩個字符串數組，問這兩個數組是否對應位置的字符串都相似。規定”相似關係“是個等價關係。如果兩個數組長度不等則直接返回false；並且如果對應位置上的字符串相等，也視爲相似，不必含在列表裏。

思路是並查集。先用一個哈希表將pair裏的單詞與一個整數進行對應。如果遍歷到一個pair的時候兩個字符串已經在哈希表裏，則執行並查集的union操作；如果只有一個在哈希表裏，則將那個不在哈希表裏的字符串與在的那個對應相同的數字；如果兩個都不在哈希表裏，則將這兩個字符串都加進哈希表裏，並對應相等的數字。代碼如下：

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
    
    class UnionFind {
        int[] parent, rank;
        UnionFind(int n) {
            parent = new int[n];
            rank = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
                rank[i] = 1;
            }
        }
        
        public int find(int p) {
            if (p != parent[p]) {
                parent[p] = find(parent[p]);
            }
            return parent[p];
        }
        
        public void union(int p, int q) {
            int pRoot = find(p), qRoot = find(q);
            if (rank[pRoot] < rank[qRoot]) {
                parent[pRoot] = qRoot;
            } else if (rank[pRoot] > rank[qRoot]) {
                parent[qRoot] = pRoot;
            } else {
                parent[pRoot] = qRoot;
                rank[qRoot]++;
            }
        }
    }
    
    public boolean areSentencesSimilarTwo(String[] words1, String[] words2, List<List<String>> pairs) {
        if (words1.length != words2.length) {
            return false;
        }
    
        UnionFind uf = new UnionFind(pairs.size());
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < pairs.size(); i++) {
            String s1 = pairs.get(i).get(0), s2 = pairs.get(i).get(1);
            // 如果哈希表裏含有兩個字符串，則並查集將對應的兩個整數union起來；
            // 如果只含其中一個，就把不含的那個對應的數字設爲含的那個對應的數字；
            // 如果都不含，就直接對應一個相等的整數
            if (map.containsKey(s1) && map.containsKey(s2)) {
                uf.union(map.get(s1), map.get(s2));
            } else if (!map.containsKey(s1) && !map.containsKey(s2)) {
                map.put(s1, i);
                map.put(s2, i);
            } else if (map.containsKey(s1)) {
                map.put(s2, map.get(s1));
            } else {
                map.put(s1, map.get(s2));
            }
        }
    
        for (int i = 0; i < words1.length; i++) {
            String s1 = words1[i], s2 = words2[i];
            // 特判一下相等的情況
            if (s1.equals(s2)) {
                continue;
            }
            // 如果不含，則直接返回false
            if (!map.containsKey(s1) || !map.containsKey(s2)) {
                return false;
            }
            // 否則看一下是否同屬同一個集合
            if (uf.find(map.get(s1)) != uf.find(map.get(s2))) {
                return false;
            }
        }
        
        return true;
    }
}

時空複雜度$O(nl)$。