LeetCode笔记（图：算各并查集大小***，dp：正方形面积）

952 - 990 - 221。

952. 按公因数计算最大组件大小*** - 算各并查集大小

可以通过定义一个size数组，每次合并两个集合时，把更新集合的大小，这样就可以直接得到各并查集的大小了！

此外这题还要用刷法选素数提高效率（一开始用辗转相除法太慢了。。。）

// 12.00
// 12.46
class Solution {
    vector<int> parent;
    vector<int> size;
    bool visited[100005];
    int index[100005];
    int ans;
    int find(int x) {
        if(x != parent[x])
            parent[x] = find(parent[x]);
        return parent[x];
    }
    void join(int x, int y) {
        int a = find(x);
        int b = find(y);
        if(a != b) {
            if(size[a] > size[b]) {
                parent[b] = a;
                size[a] += size[b];
                ans = max(ans, size[a]);
            }
            else {
                parent[a] = b;
                size[b] += size[a];
                ans = max(ans, size[b]);
            }
        }
    }
public:
    int largestComponentSize(vector<int>& numbers) {
        if(numbers.empty()) return 0;
        int n = numbers.size();
        fill(index, index + 100005, -1);
        size.resize(n, 1);
        parent.resize(n);
        int maxNumber = numbers[0];
        for(int i = 0; i < n; i++) {
            parent[i] = i;
            maxNumber = max(maxNumber, numbers[i]);
            index[numbers[i]] = i;
        }
        for(int i = 2; i <= maxNumber/2 + 1; i++) {
            if(!visited[i]) {
                visited[i] = 1;
                int tmpIndex = index[i];
                for(int k = i + i; k <= maxNumber; k += i) {
                    if(index[k] != -1) {
                        if(tmpIndex == -1) tmpIndex = index[k];
                        else join(tmpIndex, index[k]);
                    }
                    visited[k] = 1;
                }
            }
        }
        
        return ans;
    }
};

990. 等式方程的可满足性

把 == 式看作一条边，并入一个集合中，之后检查 != 式中的字母是否在同一集合中即可

// 13.20
// 13.42
class Solution {
    vector<int> parent;
    vector<int> rank;
    int find(int x) {
        if(x != parent[x])
            parent[x] = find(parent[x]);
        return parent[x];
    }
    void join(int x, int y) {
        int a = find(x);
        int b = find(y);
        if(a != b) {
            if(rank[a] > rank[b]) parent[b] = a;
            else {
                parent[a] = b;
                if(rank[a] == rank[b]) rank[a]++;
            }
        }
    }
public:
    bool equationsPossible(vector<string>& equations) {
        if(equations.empty()) return true;

        parent.resize(27);
        rank.resize(27, 0);
        for(int i = 0; i < parent.size(); i++) 
            parent[i] = i;
        
        vector<int> notEqual;
        for(auto x : equations) {
            if(x[1] == '!') notEqual.push_back(x[0] - 'a'), notEqual.push_back(x[3] - 'a');
            else join(x[0] - 'a', x[3] - 'a');
        }

        

        for(int i = notEqual.size() - 2; i >= 0; i -= 2) {
            if(find(notEqual[i]) == find(notEqual[i + 1]))
                return false;
        }
        return true;
    }
};

221. 最大正方形 - 算正方形面积

和之前的1277几乎一样

// 13.43 
// 13.56
class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.empty()) return 0;

        int ans = 0;
        for(int i = 0; i < matrix.size(); i++) {
            for(int k = 0; k < matrix[0].size(); k++) {
                matrix[i][k] -= '0';
                if(i != 0 && k != 0 && matrix[i][k]) {
                    matrix[i][k] = min(matrix[i][k - 1], min(matrix[i - 1][k], matrix[i - 1][k - 1])) + 1;
                }
                ans = max(ans, (int)matrix[i][k]);
            }
        }

        return ans * ans;
    }
};