连通图练习总结

连通图是图论基于联通的一个概念，在ACM中针对图论的考察一部分是也是基于连通图。针对这类问题的解题基本思路就是先求出对应的连通分量（有向图的强连通，无向图的双连通）对图进行简化，然后再结合其他算法计算。

1. POJ 3180 The Cow Prom

这个题如果能理解题目的话，怎么做就很明显了，能形成一个可以转圈的小群，就相当于一个强连通分量，需要注意的就是这个小群不可以只有一头牛。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")

#define     IT              iterator
#define     PB(x)           push_back(x)
#define     CLR(a,b)        memset(a,b,sizeof(a))

using namespace std;

typedef     long long               ll;
typedef     unsigned long long      ull;
typedef     vector<int>             vint;
typedef     vector<ll>              vll;
typedef     vector<ull>             vull;
typedef     set<int>                sint;
typedef     set<ull>                sull;

const int maxn = 10000 + 5;
vint G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
int a[maxn];

void init(int n) {
    for (int i = 0; i <= n; i++) G[i].clear();
}

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u],lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        while (1) {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    CLR(sccno,0);
    CLR(pre,0);
    for (int i = 1; i <= n; i++) {
        if (!pre[i]) dfs(i);
    }
}

int cnt[maxn];

int main() {
    int n,m;
    //freopen("data.in","r",stdin);
    while (cin>>n>>m) {
        init(n);
        for (int i = 0; i < m; i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a].PB(b);
        }
        //for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        find_scc(n);
        for (int i = 1; i <= n; i++) {
            cnt[sccno[i]]++;
        }
        int ans = 0;
        /*cout<<scc_cnt<<endl;
        for (int i = 1; i <= scc_cnt; i++) {
            for (int j = 0; j < new_g[i].size(); j++) {
                cout<<i<<" "<<new_g[i][j].from<<" "<<new_g[i][j].cost<<endl;
            }
        }*/
        for (int i = 1; i <= scc_cnt; i++) {
            if (cnt[i] > 1) ans++;
        }
        cout<<ans<<endl;
    }
}

2. POJ 1236 Network of Schools

最开始对于图的处理同样也是需要用强连通缩点重新构图，然后针对两个任务，第一个很好理解就是入度为0的强连通个数，第二个问题需要小小想一下，欲将整个图变成一个强连通，那么就相当于把现在的图中入度为0和出度为0的点都消灭掉（加边），那么想到这里答案就出来了，就是max{入度为0的点个数，出度为0的点个数}。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")

#define     IT              iterator
#define     PB(x)           push_back(x)
#define     CLR(a,b)        memset(a,b,sizeof(a))

using namespace std;

typedef     long long               ll;
typedef     unsigned long long      ull;
typedef     vector<int>             vint;
typedef     vector<ll>              vll;
typedef     vector<ull>             vull;
typedef     set<int>                sint;
typedef     set<ull>                sull;

const int maxn = 10000 + 5;
vint G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
int a[maxn];

void init(int n) {
    for (int i = 0; i <= n; i++) G[i].clear();
}

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u],lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        while (1) {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    CLR(sccno,0);
    CLR(pre,0);
    for (int i = 1; i <= n; i++) {
        if (!pre[i]) dfs(i);
    }
}

int in[maxn];
int out[maxn];

int main() {
    int n,m;
    //freopen("data.in","r",stdin);
    while (cin>>n) {
        init(n);
        for (int i = 1; i <= n; i++) {
            int m;
            while (scanf("%d",&m),m) {
                G[i].PB(m);
            }
        }
        //for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        find_scc(n);
        CLR(in,0);
        CLR(out,0);
        int tmpa = 0,tmpb = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < G[i].size(); j++) {
                int v = G[i][j];
                if (sccno[i] != sccno[v]) {
                    out[sccno[i]]++;
                    in[sccno[v]]++;
                }
            }
        }
        for (int i = 1; i <= scc_cnt; i++) {
            if (!out[i]) tmpb++;
            if (!in[i]) tmpa++;
        }
        cout<<tmpa<<endl<<(scc_cnt == 1 ? 0 : max(tmpb,tmpa))<<endl;
    }
}

3. POJ 2186 Popular Cows

题目给出一些仰慕关系，需要求的是被所有牛仰慕的牛的个数。由于图相对比较大，所以先强连通缩点，重新构图之后，这样之后就相对简单了，保证图连通的情况下，我们需要保证出度为0的分量只有一个，如果有多个，那么这几个分量之间必然没有倾慕关系。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")

#define     IT              iterator
#define     PB(x)           push_back(x)
#define     CLR(a,b)        memset(a,b,sizeof(a))

using namespace std;

typedef     long long               ll;
typedef     unsigned long long      ull;
typedef     vector<int>             vint;
typedef     vector<ll>              vll;
typedef     vector<ull>             vull;
typedef     set<int>                sint;
typedef     set<ull>                sull;

const int maxn = 10000 + 5;
vint G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
int a[maxn];

void init(int n) {
    for (int i = 0; i <= n; i++) G[i].clear();
}

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u],lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        while (1) {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    CLR(sccno,0);
    CLR(pre,0);
    for (int i = 1; i <= n; i++) {
        if (!pre[i]) dfs(i);
    }
}

int out[maxn];
int cnt[maxn];

int main() {
    int n,m;
    //freopen("data.in","r",stdin);
    while (cin>>n>>m) {
        init(n);
        for (int i = 0; i < m; i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a].PB(b);
        }
        //for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        find_scc(n);
        CLR(out,0);
        CLR(cnt,0);
        for (int i = 1; i <= n; i++) {
            cnt[sccno[i]]++;
            for (int j = 0; j < G[i].size(); j++) {
                int v = G[i][j];
                if (sccno[i] != sccno[v]) {
                    out[sccno[i]]++;
                }
            }
        }
        bool flag = true;
        int k = 0;
        for (int i = 1; i <= scc_cnt; i++) {
            if (k && !out[i]) {
                flag = false;
                break;
            }
            if (!out[i]) k = i;
        }
        if (flag) cout<<cnt[k]<<endl;
        else cout<<0<<endl;
    }
}

4. HDU 3861 The King’s Problem

题目读完之后发现应该是最小路径覆盖，但是两个问题：数据范围和图有环。先强连通缩点，重新构图，这样图就变成了DAG，在应用Hungary算法就可以求出答案了。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")

#define     IT              iterator
#define     PB(x)           push_back(x)
#define     CLR(a,b)        memset(a,b,sizeof(a))

using namespace std;

typedef     long long               ll;
typedef     unsigned long long      ull;
typedef     vector<int>             vint;
typedef     vector<ll>              vll;
typedef     vector<ull>             vull;
typedef     set<int>                sint;
typedef     set<ull>                sull;

const int maxn = 50000 + 5;
vint G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
int a[maxn];

void init(int n) {
    for (int i = 0; i <= n; i++) G[i].clear();
}

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u],lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        while (1) {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    CLR(sccno,0);
    CLR(pre,0);
    for (int i = 1; i <= n; i++) {
        if (!pre[i]) dfs(i);
    }
}

vint new_g[maxn];
int match[maxn];
bool vis[maxn];

bool findpath(int u) {
    for (int i = 0; i < new_g[u].size(); i++) {
        int v = new_g[u][i];
        if (!vis[v]) {
            vis[v] = 1;
            if (match[v] == -1 || findpath(match[v])) {
                match[v] = u;
                return true;
            }
        }
    }
    return false;
}

int hungary() {
    int ans = 0;
    CLR(match,-1);
    for (int i = 1; i <= scc_cnt; i++) {
        CLR(vis,0);
        if (findpath(i)) ans++;
    }
    return ans;
}

int main() {
    //freopen("data.in","r",stdin);
    int n,m;
    int T;
    cin>>T;
    while (T--) {
        cin>>n>>m;
        init(n);
        for (int i = 0; i < m; i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a].PB(b);
        }
        //for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        find_scc(n);
        for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < G[i].size(); j++) {
                int v = G[i][j];
                if (sccno[i] != sccno[v]) {
                    new_g[sccno[i]].PB(sccno[v]);
                }
            }
        }
        cout<<scc_cnt - hungary()<<endl;
    }
}

5. HDU 3639 Hawk-and-Chicken

开始还是老套路，先强连通缩点，需要注意的话这个题重新构图需要反向建边，然后对每个入度0的点DFS，求最大值即可。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")

#define     IT              iterator
#define     PB(x)           push_back(x)
#define     CLR(a,b)        memset(a,b,sizeof(a))

using namespace std;

typedef     long long               ll;
typedef     unsigned long long      ull;
typedef     vector<int>             vint;
typedef     vector<ll>              vll;
typedef     vector<ull>             vull;
typedef     set<int>                sint;
typedef     set<ull>                sull;

const int maxn = 5000 + 5;
vint G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
stack<int> S;
int a[maxn];

void init(int n) {
    for (int i = 0; i <= n; i++) G[i].clear();
}

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u],lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u],pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        while (1) {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    CLR(sccno,0);
    CLR(pre,0);
    for (int i = 0; i < n; i++) {
        if (!pre[i]) dfs(i);
    }
}

vint new_g[maxn];
int rec[maxn];
int out[maxn];
int lab[maxn];
bool vis[maxn];
int cnt;

int dp(int u) {
    vis[u] = true;
    cnt += lab[u];
    for (int i = 0; i < new_g[u].size(); i++) {
        int v = new_g[u][i];
        if (!vis[v]) {
            dp(v);
        }
    }
    return cnt;
}

int main() {
    //freopen("data.in","r",stdin);
    int n,m;
    int T;
    cin>>T;
    for (int t = 1; t <= T; t++) {
        cin>>n>>m;
        init(n);
        for (int i = 0; i < m; i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a].PB(b);
        }
        find_scc(n);
        CLR(out,0);
        CLR(lab,0);
        for (int i = 0; i <= scc_cnt; i++) new_g[i].clear();
        for (int i = 0; i < n; i++) {
            lab[sccno[i]]++;
            for (int j = 0; j < G[i].size(); j++) {
                int v = G[i][j];
                if (sccno[i] != sccno[v]) {
                    new_g[sccno[v]].PB(sccno[i]);
                    out[sccno[i]]++;
                }
            }
        }
        CLR(rec,0);
        int ans = 0;
        for (int i = 1; i <= scc_cnt; i++) {
            if (!out[i]) {
                CLR(vis,0);
                cnt = 0;
                rec[i] = dp(i);
                ans = max(ans,rec[i]);
            }
        }
        /*for (int i = 0; i < n; i++) {
            cout<<sccno[i]<<" ";
        }
        cout<<endl;
        for (int i = 1; i <= scc_cnt; i++) {
            cout<<rec[i][0]<<" "<<rec[i][1]<<endl;
        }*/
        printf("Case %d: %d\n",t,ans - 1);
        bool flag = false;
        for (int i = 0; i < n; i++) {
            if (rec[sccno[i]] == ans) {
                if (flag) printf(" %d",i);
                else {
                    printf("%d",i);
                    flag = true;
                }
            }
        }
        printf("\n");
    }
}
时间： 2024-10-08 22:33:25

连通图练习总结的相关文章

题目1545：奇怪的连通图

奇怪的连通图 题目描述: 已知一个无向带权图,求最小整数k.使仅使用权值小于等于k的边,节点1可以与节点n连通. 输入: 输入包含多组测试用例,每组测试用例的开头为一个整数n(1 <= n <= 10000),m(1 <= m <= 100000),代表该带权图的顶点个数,和边的个数.接下去m行,描述图上边的信息,包括三个整数,a(1 <= a <= n),b(1 <= b <= n),c(1 <= c <= 1000000),表示连接顶点a和顶

【连通图|强连通分量+缩点】POJ-1236 Network of Schools

Network of Schools Time Limit: 1000MS Memory Limit: 10000K Description A number of schools are connected to a computer network. Agreements have been developed among those schools: each school maintains a list of schools to which it distributes softwa

求无向连通图的割点

求一个连通图的割点,割点的定义是,如果除去此节点和与其相关的边,图不再连通. 连通图的定义:如果图中任意两点都是连通的,那么图被称作连通图.如果此图是有向图,则称为强连通图(注意:需要双向都有路径) 割点:在无向连通图中,删除一个顶点v及其相连的边后,原图从一个连通分量变成了两个或多个连通分量,则称顶点v为割点,同时也称关节点 (Articulation Point).多连通图没有割点,若在多连通图上至少删去k个顶点才能破坏图的连通性,则称此图为k连通图.貌似有向连通图没有割点这个说法. 连通分

POJ 1236 Network of Schools 连通图缩点

题目大意:有向图连通图,第一问求至少需要多少个软件才能传输到所有学校,第二问求至少需要增加多少条路使其成为强连通图 题目思路:利用Tarjan算法经行缩点,第一问就是求缩点后入度为0的点的个数(特殊情况,当缩点后仅剩一个点是输出0),第二问就是求缩点后max(入度为0的点的个数,出度为0的点的个数). #include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> #inclu

连通图基本知识

看了LRJ的训练指南上连通有关的介绍,写得挺好,但是有些位置逻辑跳跃比较大,还有一些留给读者思考的位置,在此做个总结. 1.DFS框架 2.连通分量 3.二分图判定 4.无向图的割顶和桥 5.无向图的双连通分量 6.有向图的强连通分量(Tarjan算法) 1.DFS框架 连通图很多都是跟DFS框架里面的previsit()和posvisit()有关,不多说. vector<int> G[maxn]; int vis[maxn]; void dfs(int u) { vis[u]=1; prev

双连通分量+构造双连通图

构造双连通图:一个有桥的连通图,如何把它通过加边变成边双连通图? 一个有桥的连通图,如何把它通过加边变成边双连通图?方法为首先求出所有的桥,然后删除这些桥边,剩下的每个连通块都是一个双连通子图.把每个双连通子图收缩为一个顶点,再把桥边加回来,最后的这个图一定是一棵树,边连通度为1. 统计出树中度为1的节点的个数,即为叶节点的个数,记为leaf.则至少在树上添加(leaf+1)/2条边,就能使树达到边二连通,所以至少添加的边数就是(leaf+1)/2.具体方法为,首先把两个最近公共祖先最远的两个叶

【连通图】双连通模板 Tarjan

比起求无向图关节点的算法,只是多了一个栈,用来储存不存在关节点的所有边,遇到关节点之后弹出所有边进行储存 int dfs(int u, int fa) { int lowu = dfn[u] = ++deep; int son = 0; for(int i = head[u]; ~i; i = e[i].next) { int v = e[i].v; Pair p = Pair(u, v); if(!dfn[v]) { s.push(p); son++; int lowv = dfs(v, u)

连通图的一些性质

基本定义:对于无向图G=(V,E),若对于V中任意结点对v,u,v与u之间总是有一条路径(由E中的若干条边组成)相连接,那么称G是连通图. 命题1:对于连通图G=(V,E),必然有|E|>=|V|-1. 证明:首先要认清一个图G=(V,E)必然是由若干个互不关联的子连通图组成的.继而,需要证明每次向图中增加一条边,或者不影响其互不关联的子连通图的数目(这条边落在了一个子连通图的内部),或者使得原图中两个子连通图相互连通,从而新的图中互不关联的子连通图的数目较原图减少1. 命题2:对于连通图G=(

Hdu 4738 Caocao&#39;s Bridges （连通图+桥）

题目链接: Hdu 4738 Caocao's Bridges 题目描述: 有n个岛屿,m个桥,问是否可以去掉一个花费最小的桥,使得岛屿边的不连通? 解题思路: 去掉一个边使得岛屿不连通,那么去掉的这个边一定是一个桥,所以我们只需要求出来所有的桥,然后比较每个桥的花费,选取最小的那个就好. 看起来很简单的样子哦!但是这个题目有很多的细节: A:题目中有重边,以后写Tarjan还是清一色判断重边吧.(除非题目特别要求) B:m个桥有可能连通不了这n个桥,这个时候不需要花费. C:当最小花费桥的花费

poj Transferring Sylla（如何快速的判断一个图是否是3—连通图，求割点，割边）

Transferring Sylla 首先,什么是k连通图?k连通图就是指至少去掉k个点使之不连通的图. 题目: 题目描述的很裸,就是给你一张图要求你判断这图是否是3-连通图. 算法分析: ///////////////////////////////////////////////////////////////////// (网上别人的分析,分析的很好所以直接引用了) 考虑一下不可行的情况,就是存在两点间的路径条数<3情况,那么我们可以去枚举两个点a和b,然后将其和相邻的边删除,然后判断联通