Leetcode daily questions (2316. count unreachable pairs of nodes in an undirected graph)

You are given an integer n. There is an undirected graph with n nodes, numbered from 0 to n - 1. You are given a 2D integer array edges where edges[i] = [ai, bi] denotes that there exists an undirected edge connecting nodes ai and bi.

Return the number of pairs of different nodes that are unreachable from each other.

Example 1:

Input: n = 3, edges = [[0,1],[0,2],[1,2]]
Output: 0

Explanation: There are no pairs of nodes that are unreachable from each other. Therefore, we return 0.

Example 2:

Input: n = 7, edges = [[0,2],[0,5],[2,4],[1,6],[5,4]]
Output: 14

Explanation: There are 14 pairs of nodes that are unreachable from each other:
[[0,1],[0,3],[0,6],[1,2],[1,3],[1,4],[1,5],[2,3],[2,6],[3,4],[3,5],[3,6],[4,6],[5,6]].
Therefore, we return 14.

Constraints:

• 1 <= n <= 105
• 0 <= edges.length <= 2 * 105
• edges[i].length == 2
• 0 <= ai, bi < n
• ai != bi
• There are no repeated edges.

---

use union-find To turn every isolated graph into a tree , Then we can get the number of nodes in each tree , hypothesis nodes[i] Is the number of nodes in the current tree , that n - nodes[i] Is the number of nodes that are not connected to the nodes in the current tree , nodes[i] * (n - nodes[i]) Namely pair The number of , Traverse all the numbers to calculate pair The final answer is to add up the quantity

---

use std::collections::HashMap;

impl Solution {
    
    fn find(parent: &mut Vec<i32>, n: i32) -> i32 {
    
        let mut p = parent[n as usize];
        if p == n {
    
            return p;
        }
        p = Solution::find(parent, p);
        parent[n as usize] = p;
        p
    }

    fn union(parent: &mut Vec<i32>, a: i32, b: i32) {
    
        let pa = Solution::find(parent, a);
        let pb = Solution::find(parent, b);
        parent[pa as usize] = pb;
    }

    pub fn count_pairs(n: i32, edges: Vec<Vec<i32>>) -> i64 {
    
        let mut parent: Vec<i32> = (0..n).collect();
        for e in edges {
    
            Solution::union(&mut parent, e[0], e[1]);
        }
        while {
    
            let mut modified = false;
            for i in 0..n as usize {
    
                let pp = parent[parent[i] as usize];
                if parent[i] != pp {
    
                    Solution::union(&mut parent, i as i32, pp);
                    modified = true;
                }
            }
            modified
        } {
    }
        let m = parent.into_iter().fold(HashMap::new(), |mut m, v| {
    
            *m.entry(v).or_insert(0) += 1;
            m
        });
        let mut ans = 0;
        for v in m.values() {
    
            ans += *v * (n as i64 - *v);
        }
        ans / 2
    }
}