典型算法与ACM题目解析(2)—有向图的强连通分量

最新推荐文章于 2022-09-07 10:08:31 发布
最新推荐文章于 2022-09-07 10:08:31 发布
阅读量3.5k 收藏 2
点赞数
分类专栏： 原创文章 ACM题库 算法思想 C++语言 翻译文章 文章标签： 算法 algorithm insert struct graph path
本文介绍了解决牛群仰慕关系问题的方法，利用有向图的强连通分量算法找出最受欢迎的牛。通过Kosaraju和Gabow算法实现，详细展示了代码实现过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  
典型算法与ACM题目解析(2)—有向图的强连通分量
 
    这道题是POJ的2186题，题意是说，有一群牛，总数为N(N<=10000),题目数据给出牛之间的关系，比如说1仰慕2，2仰慕3等等，设这种仰慕是可以传递的，如果1仰慕2，那么1也会同时仰慕2仰慕的那些牛，如果一头牛被所有的牛都仰慕，那么它将是最受欢迎的牛，题目要求的是有多少牛是"最受欢迎的"。
 
这道题目大家第一眼看到可能感觉直接模拟，但是由于数据量巨大，模拟的话肯定是过不了的，而且题目中还会出现环路的情况，比如1=>2,2=>3,3=>1，所以这解这道题最好的方法是使用有向图的强连通分量。
 
在同一个强连通分量里的所有的牛之间是互相仰慕的，我们将其缩为一点，并且只记录这一点的牛的数量，如果有最受欢迎的牛存在，那么这个图将是连通图，并且出度为零的点只有一个，我们可以用并查集来判是否连通，然后计算每个节点的出度，即可求出最受欢迎的牛的数量。
 
求强连通分量有三种算法，分别是Kosaraju算法，Gabow算法和Tarjan算法，其中Kosaraju算法要对原图和逆图都进行一次DFS，而另外两种算法只要DFS一次就可以了。
 
用了Gabow算法和Kosaraju算法各写了一遍。
 
在时间上Gabow算法是122ms,Kosaraju算法是61ms
理论上Gabow算法要比Kosaraju快些的，因为Gabow算法只对原图进行一次DFS，而Kosaraju要进行两次
Gabow反而慢的原因可能是我用了STL里的stack
 
PS:我没看懂Gabow算法，完全是对着书上写的
 
代码如下:
 
Kosaraju算法
 
/*
    求有向图的强连通分量的Kosaraju's algorithm
    By Sempr ---- 2006.06.16
*/
#include <stdio.h>
#include <string.h>
#define G_size 100000
#define V_size 11000
 
typedef struct Graph
{
    int id;
    int next;
} Graph;
 
typedef struct Edge
{
    int s, e;
} Edge;
 
Edge E[G_size];
Graph GA[G_size], GT[G_size];
int N, M;
int G_end;
int order[V_size], id[V_size], vis[V_size], in[V_size];
int cnt, scnt, pos;
 
void Insert(int s, int e) //建立原图和逆图
{
    int p;
    p = s;
    while (GA[p].next)
        p = GA[p].next;
    GA[G_end].id = e;
    GA[p].next = G_end;
 
    p = e;
    while (GT[p].next)
        p = GT[p].next;
    GT[G_end].id = s;
    GT[p].next = G_end;
 
    G_end++;
}
 
void DFST(int x) //对逆图进行搜索
{
    int p, q;
    vis[x] = 1;
    p = GT[x].next;
    while (p)
    {
        q = GT[p].id;
        if (!vis[q])
            DFST(q);
        p = GT[p].next;
    }
    order[cnt++] = x;
}
 
void DFSA(int x) //对原图进行搜索
{
    int p, q;
    vis[x] = 1;
    id[x] = cnt;
    p = GA[x].next;
    while (p)
    {
        q = GA[p].id;
        if (!vis[q])
            DFSA(q);
        p = GA[p].next;
   }
}
 
void Solve() //主要过程
{
    int s, e;
    int i;
 
    memset(GA, 0, sizeof(GA));
    memset(GT, 0, sizeof(GT));
    memset(E, 0, sizeof(E));
    G_end = N + 1;
 
    for (i = 0; i < M; i++)
    {
        scanf("%d %d", &s, &e);
        E[i].s = s - 1;
        E[i].e = e - 1;
        Insert(s - 1, e - 1);
    }
 
    memset(vis, 0, sizeof(vis));
    cnt = 0;
    for (i = 0; i < N; i++)
    {
        if (!vis[i])
        {
            DFST(i);
        }
    }
 
    memset(vis, 0, sizeof(vis));
    cnt = 0;
    for (i = N - 1; i >= 0; i--)
    {
        if (!vis[order[i]])
        {
            DFSA(order[i]);
            cnt++;
        }
    }
 
    for (i = 0; i < M; i++)
    {
        s = id[E[i].s];
        e = id[E[i].e];
        if (s != e)
        {
            in[s]++;
        }
    }
    scnt = cnt;
    cnt = 0;
    for (i = 0; i < scnt; i++)
    {
        if (in[i] == 0)
        {
            pos = i;
            cnt++;
        }
    }
    if (cnt != 1)
    {
        printf("0/n");
    }
    else
    {
        cnt = 0;
        for (i = 0; i < N; i++)
        {
            if (in[id[i]] == pos)
            {
                cnt++;
            }
        }
        printf("%d/n", cnt);
    }
}
 
int main()
{
    while (EOF != scanf("%d %d", &N, &M))
        Solve();
    return 0;
}
 
Gabow算法
/*
    求有向图的强连通分量的Gabow's algorithm
    By Sempr ---- 2006.06.14
*/
#include <stdio.h>
#include <algorithm>
#include <stack>
#define size 11000
using namespace std;
 
int N, M;
 
typedef struct Node
{
    int id;
    int next;
} Node;
 
typedef struct Edge
{
    int s, e;
}Edge;
 
Edge E[size * 6];
Node G[size * 7];
int pre[size], id[size];
typedef stack<int> Stack;
Stack S, path;
int end;
int cnt, scnt;
int vis[size];
int in[size];
 
void Insert(int s, int e)
{
    int p = s;
    while (G[p].next)
    {
        p = G[p].next;
        if (G[p].id == e)
        {
            return;
        }
    }
   G[p].next = end;
    G[end].id = e;
    end++;
}
 
void scR(int w)
{
    int v;
    int p, t;
    pre[w] = cnt++;
    S.push(w);
    path.push(w);
    p = G[w].next;
    while (p)
    {
        t = G[p].id;
        p = G[p].next;
        if (pre[t] == -1)
            scR(t);
        else if (id[t] == -1)
            while (pre[path.top()] > pre[t])
                path.pop();
    }
    if (path.top() == w)
        path.pop();
    else
        return;
    do
    {
        id[v = S.top()] = scnt;
        S.pop();
    }
    while (v != w);
    scnt++;
}
 
void Gabow()
{
    int i;
    memset(pre, -1, sizeof(pre));
    memset(id, -1, sizeof(id));
    cnt = 0;
    scnt = 0;
    while (!S.empty())
        S.pop();
    while (!path.empty())
        path.pop();
    for (i = 1; i <= N; i++)
    {
        if (pre[i] == -1)
        {
            scR(i);
        }
    }
}
 
void DFS(int w, int d)
{
    int p = G[w].next;
    d++;
    pre[w] = 1;
    if (d > cnt)
    {
        cnt = d;
    }
    while (p)
    {
        if (pre[G[p].id] != 1)
        {
            DFS(G[p].id, d);
        }
        p = G[p].next;
    }
}
 
void Solve()
{
    int i, s, e;
    int pos;
    memset(G, 0, sizeof(G));
    end = N + 10;
    memset(in, 0, sizeof(in));
    for (i = 0; i < M; i++)
    {
        scanf("%d %d", &s, &e);
        E[i].s = s;
        E[i].e = e;
        Insert(s, e);
    }
    Gabow();
    memset(G, 0, sizeof(G));
    memset(pre, 0, sizeof(pre));
    end = scnt + 10;
    for (i = 0; i < M; i++)
    {
        s = id[E[i].s];
        e = id[E[i].e];
        if (s != e)
        {
            in[s]++;
        }
    }
    cnt = 0;
    for (i = 0; i < scnt; i++)
    {
        if (in[i] == 0)
        {
            pos = i;
            cnt++;
        }
    }
    if (cnt != 1)
    {
        printf("0/n");
    }
    else
    {
        cnt = 0;
        for (i = 1; i <= N; i++)
        {
            if (in[id[i]] == pos)
            {
                cnt++;
            }
        }
        printf("%d/n", cnt);
    }
}
 
int main()
{
    while (scanf("%d %d", &N, &M) != EOF)
        Solve();
    }
    return 0;
}
 
 
第三部分 图论算法 （第四章 强连通分量）例题
蒟蒻こんにゃく
05-13 613
例题一： 有向图缩点 link 思路： 大家一开始可能都会想到直接用SPFA跑最长路，时间复杂度为O(nm)O(nm)O(nm)， 看看数据，TLE是必然的。 那有没有时间更优的方法——强连通分量。 分析题意，每个点点权只被计算一次，允许一条边走多次， 那我们考虑用Tarjan来进行缩点， 使图变成有向无环图，再进行DPDPDP。 设转移方程为：f=max(fu+disv,fv)f=max(f_u+dis_v,f_v)f=max(fu​+disv​,fv​) fif_ifi​表示以i作为终点的路径所经过
有向图的强连通分量 模板
潮鸣り
07-25 440
const int MAXN = 10010; //点数 const int MAXM = 100100; //边数 struct edge { int to,next; } edge[MAXM]; int head[MAXN],tot; int Low[MAXN],DFN[MAXN],Stack[MAXN]; int Belong[MAXN]; //标记当前点属于第几个强连通分量
有向图的强连通分量算法
10-26
求用连接表存储的有向图的强连通分量的算法
Kosaraju算法 有向图的强连通分量
weixin_30383279的博客
01-18 200
有向图的强连通分量即，在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。 采用的算法是Kosaraju算法。 算法原理：对于图G，转置图（同图中的每边的方向相反）具...
有向图的强联通分量相关例题（Korasaju算法和Tarjan算法）
serendipity的博客
08-22 537
有向图的强联通分量相关例题（Korasaju算法和Tarjan算法） 一、poj 2186：Popular Cows 即：强连通分量+缩点 还是很菜，都是照着大佬的板子敲的，而且还不是很熟练 Korasaju算法 实现 /**korasaju算法*/ #include<cstdio> #include<cstring> #include<algorithm>...
【图论】—— 有向图的强连通分量
forever_bryant的博客
06-19 3240
【图论】—— 有向图的强连通分量
ACM竞赛题目解析：有向图强连通分量算法探讨
"这篇内容主要解析ACM竞赛中的有向图强连通分量问题，通过举例讲解了一道POJ的2186题，涉及到了牛群之间的仰慕关系，以及如何寻找最受欢迎的牛。解决此类问题的关键是利用有向图的强连通分量理论，并提到了Kosaraju...
有向图强连通分量求解：Tarjan算法与Kosaraju算法解析
Tarjan算法是求解有向图强连通分量的一种有效方法，它基于深度优先搜索（DFS）。该算法通过维护一个栈来辅助搜索，每个强连通分量对应于搜索树中的一棵子树。在搜索过程中，未处理的节点会被添加到栈中。算法的核心...
有向图强连通分量求解算法解析：Tarjan与Kosaraju
求解有向图的强连通分量是图论算法中的核心问题，有几种经典算法可用于解决这一问题，包括Tarjan算法和Kosaraju算法。 1. Tarjan算法基于深度优先搜索(DFS)。该算法首先对图进行DFS遍历，同时维护一个栈来记录当前...
典型算法与ACM题目解析
06-03
1. 寻找最大流的标号法 2. 有向图的强连通分量 3. 记忆化搜索的应用
ACM:ICPC竞赛训练课件：强连通分量.pdf
最新发布
06-19
ACM:ICPC竞赛训练课件中的强连通分量概念涵盖了有向图中顶点间的相互可达性。在有向图G中，若任意两个不同的顶点之间都可互相到达，则称此有向图为强连通的。对于极大强连通子图，称其为有向图G的强连通分支。而转置...
有向图的强连通分量 模版
c3po
10-08 302
const int MAXN=20010;//点数 const int MAXM=50010;//边数 struct Edge { int to,next; }edge[MAXM]; int head[MAXN],tot; int low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1～scc int Index,top; in...
【算法题归纳合集】图论-有向图的强连通分量
一只快乐的小蒟蒻~
03-23 1688
一、AcWing 1174. 受欢迎的牛 【题目描述】 每一头牛的愿望就是变成一头最受欢迎的牛。 现在有NNN头牛，编号从1∼N1\sim N1∼N，给你MMM对整数(A,B)(A,B)(A,B)，表示牛AAA认为牛BBB受欢迎。 这种关系是具有传递性的，如果AAA认为BBB受欢迎，BBB认为CCC受欢迎，那么牛AAA也认为牛CCC受欢迎。 你的任务是求出有多少头牛被除自己之外的所有牛认为是受欢迎的。 【输入格式】 第一行两个数N,MN,MN,M； 接下来MMM行，每行两个数A,BA,BA,B，意思是AAA
有向图的强连通分量（Tarjian）
Stormjing的博客
07-27 3832
强连通分量 有向图强连通分量：在有向图G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected components)。 下图中，子图{1,2,3,...
有向图强连通分量（核心代码图解分析）
Aczy156的博客
08-15 1053
理解有向图的强连通分量 每两个顶点都至少有一条路径（A->B,B->A），然后称这两个顶点具有强联通性，这两个顶点组成的图为强连通图。 从这个途中看到，阴影部分是强连通图，拿6看，6与7不是强连通图的原因是7到6可以，但是6到7找不到一条路径。 Tarjan算法 对tarjan对计算强连通分块计算理解： 首先给传入了节点1，遍历1附近的点，先遍历到了2，3未被访问，进栈； 然后遍历3...
图论——有向图的强连通分量(未完成)
fujang的博客
02-06 362
图论——有向图的强连通分量 对于一个有向图来说，连通分量度不爱对于分量中任意两点uuu，vvv，必然可以从uuu走到vvv，也可以从vvv走到uuu。 强联通分量SCCSCCSCC指的是极大连通分量。 时间复杂度O(n+m)O(n+m)O(n+m)。 有向图的强联通分量做法通常思路为：有向图——>缩点(将所有联通分量缩成一个点)——>有向无环图(DAG拓扑图)。 TarjanTarjanTarjan算法求解SCCSCCSCC时引入了时间戳的概念：dfn[u]dfn[u]dfn[u]打表遍历到u
有向图强连通分量tarjan算法详解（适合新手） + 模板题：《信息学奥赛一本通》 , USACO , HAOI2006 受欢迎的牛
qq_61935738的博客
09-07 546
有向图强连通分量tarjan算法详解（适合新手） + 模板题：《信息学奥赛一本通》 , USACO , HAOI2006 受欢迎的牛
ACM: 图论题 poj 2186 强连通分量
smile_benson
05-19 312
Popular Cows   Description Every cow's dream is to become the most popular cow in the herd. In a herd of N (1 <= N <= 10,000) cows, you are given up to M (1 <= M <= 50,000) ordered pairs of the form (
【强连通分量缩点 经典好题】POJ - 2186 A - Popular Cows
qq_41037114的博客
08-23 244
A - Popular Cows  POJ - 2186  Every cow's dream is to become the most popular cow in the herd. In a herd of N (1 &lt;= N &lt;= 10,000) cows, you are given up to M (1 &lt;= M &lt;= 50,000) ordered pai...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值