Communication（Floyed+并查集 || Trajan）

题目：Communication

 

 

 数据：

3
6
2 0 5 5 0
5
7 0 1 0 2 1 0 1 3 2 4 3 1 4 2
3
4 0 1 0 2 1 0 1 2

 题意：就是告诉你如果A --> B表示A可以向B传送消息，如果A可以向B传送消息，B也可以向A传送消息，那么A和B就在一组，问你一共有几组。

思路：一开始很容易想到，用一个数组vis[a][b]  = vis[b][a] = 1, 就表示a, b在一组，然后使用并查集，把同一组的放在一起，查找一共有多少组，但是这个过程中存在一个问题，那就是如果a->b, b->c, c->d, d->a,那么a, d也是一组的，所以需要Floyed算法去维护vis数组。

代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 2000;
int vis[maxn][maxn];
int f[maxn];
int Find(int x)//并查集
{
    if(x == f[x])return x;
    return f[x] = Find(f[x]);
}
void Init(int n)
{
    for(int i = 0; i < n; i++)
    {
        f[i] = i;
    }
}
int main()
{
    int T, n, a, b;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        Init(n);
        int p;
        memset(vis, 0, sizeof(vis));//千万记得初始化
        scanf("%d", &p);
        for(int i = 1; i <= p; i++)
        {
            scanf("%d %d", &a, &b);
            vis[a][b] = 1;
        }
        for(int k = 0; k < n; k++)//loyed算法
        {
            for(int i = 0; i < n; i++)
            {
                for(int j = 0; j < n; j++)
                {
                    if(vis[i][k] && vis[k][j])vis[i][j] = 1;
                }
            }
        }
        for(int i = 0; i < n-1; i++)
        {
            for(int j = i+1; j < n; j++)
            {
                if(vis[i][j] + vis[j][i] == 2)
                {
                    int x = Find(i);
                    int y = Find(j);
                    if(x != y){
                        f[x] = y;
                    }
                }
            }
        }
        int cn = 0;
        for(int i = 0; i < n; i++)//数组f[i] == i的就是这一组的祖先，统计有多少个祖先就是多少组
        {
            if(Find(i) == i)cn++;
        }
        cout<<cn<<endl;
    }

    return 0;
}

另外一个算法强连通分量，通过使用Tarjan实现

参考博客：浅析强连通分量（Tarjan和kosaraju）

代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 210;
const int N = 100005;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0;
int head[N];
int ins[maxn];
int dfn[maxn], low[maxn];
struct edge
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0;
    memset(ins, 0, sizeof(ins));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0,sizeof(low));
    memset(head, -1, sizeof(head));
}
int main()
{
    int T, p, u, v;
    scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d %d", &n, &p);
        for(int i = 1; i <= p; i++)
        {
            scanf("%d %d", &u, &v);
            add(u, v);
        }
        for(int i= 0; i < n; i++)if(!dfn[i])tarjan(i);
        printf("%d\n", Bcnt);
    }
    return 0;
}