547_朋友圈

最新推荐文章于 2020-11-22 16:56:42 发布

原创最新推荐文章于 2020-11-22 16:56:42 发布 · 254 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

leetcode 专栏收录该内容

30 篇文章

订阅专栏

本文介绍了一种算法，用于计算由朋友关系构成的社交网络中的独立朋友圈数量。通过深度优先搜索（DFS）、广度优先搜索（BFS）及并查集三种方法，解决了一个N*N矩阵表示的学生间朋友关系问题，目标是找出所有学生中已知的朋友圈总数。

题目

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。

给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

示例 1:

输入:
[[1,1,0],
[1,1,0],
[0,0,1]]
输出: 2
说明：已知学生0和学生1互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回2。
示例 2:

输入:
[[1,1,0],
[1,1,1],
[0,1,1]]
输出: 1
说明：已知学生0和学生1互为朋友，学生1和学生2互为朋友，所以学生0和学生2也是朋友，所以他们三个在一个朋友圈，返回1。
注意：

N 在[1,200]的范围内。
对于所有学生，有M[i][i] = 1。
如果有M[i][j] = 1，则有M[j][i] = 1。

思路

1、DFS或BFS
2、并查集

代码

//
// Created by HINTS on 2018/12/25.
//

//
// Created by HINTS on 2018/12/13.
//
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

//使用DFS(深度优先搜索算法)+递归实现
/**
 *
 * @param M
 * @param K 当前便利节点
 * @param visited 是否遍历过
 */
 /*
void dfs_547(vector<vector<int >> &M, int k, vector<bool> &visited){
    visited[k] = true;
    for (int i = 0; i < M.size(); ++i) {
        if(!M[k][i] || visited[i])
            continue;
        else
            dfs_547(M, i, visited);
    }
}
int findCircleNum(vector<vector<int>>& M){
   int n = M.size(), res = 0;
   vector<bool> visited(n, false);
    for (int i = 0; i < n; ++i) {
        if(visited[i])
            continue;
        dfs_547(M, i, visited);
        ++res;
    }
    return res;
}
  */

 //解法2：BFS遍历
/*
 int findCircleNum(vector<vector<int >> &M){
     int n = M.size(), res = 0;
     vector<bool> visited(n, false);
     queue<int> q; //队列
     for (int i = 0; i < n; ++i) {
         if(visited[i])
             continue;
         q.push(i);//为遍历过节点i就加入队列中
         while (!q.empty()){
             int t = q.front();
             q.pop();
             visited[t] = true;
             for (int j = 0; j < n; ++j) {
                 if(!M[t][j] || visited[j])
                     continue;
                 q.push(j);
             }
         }
         ++res;
     }
     return res;
 }
*/

//解法3：使用并查集
int getRoot(vector<int > &root, int i){
    //根据并查集，当i和root[i]相同时，i的值就是根节点。
    while (i != root[i]){
        root[i] = root[root[i]];
        i = root[i];
    }
    return i;
}

int findCircleNum(vector<vector<int >> &M){
    int n = M.size(), res = n; //res=n,为最大朋友圈数，即每个人自己都是一个朋友圈
    vector<int > root(n);
    for (int i = 0; i < n; ++i) {
        root[i] = i;//初始每个节点的根为其自己
    }
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if(M[i][j] == 1){
                int p = getRoot(root, i);
                int q = getRoot(root, j);
                if(p != q){
                    --res;
                    root[q] = p;
                }
            }
        }
    }
    return res;
}

int main(){
    vector<vector<int>> grid = {{1, 0, 0, 1},
                                {0, 1, 1, 0},
                                {0, 1, 1, 1},
                                {1, 0, 1, 1}};

    int res = findCircleNum(grid);
    cout << res << endl;
    return 0;
}

参考

Grandyang