[Leetcode] 547. Friend Circles 解题报告

题目：

There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.

Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the ith and jth students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.

Example 1:

Input: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle. 
The 2nd student himself is in a friend circle. So return 2.

Example 2:

Input: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
Output: 1
Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends, 
so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.

Note:

1. N is in range [1,200].
2. M[i][i] = 1 for all students.
3. If M[i][j] = 1, then M[j][i] = 1.

思路：

1、DFS：定义一个visited数组，表示截止目前哪些朋友都被访问过了。然后依次遍历，一旦发现一个没有被访问过的朋友，则说明多了一个朋友圈，此时再用DFS将他所有的朋友都置为已访问。

2、Union-Find：对于这道题目，其实更直观的思路是Union-Find。也就是我们首先初始化每个人都拥有独立的朋友圈，然后检查任意两个人i和j，如果发现他们之间是朋友，但是目前尚不属于同一个朋友圈，那么就将他们的朋友圈合并。每合并一次，朋友圈的数量就减1，最后返回朋友圈的数量即可。

代码：

1、DFS：

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        if (M.size() == 0 || M[0].size() == 0) {
            return 0;
        }
        int row_num = M.size();
        vector<bool> visited(row_num, false);
        int groups = 0;
        for (int i = 0; i < visited.size(); ++i) {
            groups += dfs(i, M, visited) > 0;
        }
        return groups;
    }
private:
    int dfs(int i, vector<vector<int>>& M, vector<bool>& visited) {
        if (visited[i]) {
            return 0;
        }
        int ppl = 1;                                // number of friends in the group
        visited[i] = true;
        for (int j = 0; j < visited.size(); j++) {  // find the friends of i
            if (i != j && M[i][j]) {
                ppl += dfs(j, M, visited);
            }
        }
        return ppl;
    }
};

2、Union-Find：

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        if (M.size() == 0 || M[0].size() == 0) {
            return 0;
        }
        int n = M.size();                       // the number of friends
        vector<int> parents(n, 0);
        for (int i = 0; i < n; ++i) { 
            parents[i] = i;                     // initialize leads for every kid as themselves
        }   
        int groups = n;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {   // avoid recalculate M[i][j] and M[j][i]
                if (M[i][j]) {
                    int parent1 = find(i, parents);
                    int parent2 = find(j, parents);
                    if (parent1 != parent2) {   // if 2 group belongs 2 different parents, merge them
                        parents[parent1] = parent2;
                        --groups;
                    }
                }
            }
        }
        return groups;
    }
private:
    int find(int x, vector<int>& parents) {
        return parents[x] == x ? x : find(parents[x], parents);
    }
};