ACM连通图问题总结

最新推荐文章于 2023-09-13 16:50:52 发布

limn2o4

最新推荐文章于 2023-09-13 16:50:52 发布

阅读量697

点赞数

分类专栏： ACM Problems

本文链接：https://blog.csdn.net/lingzidong/article/details/80737985

版权

这篇博客总结了连通图相关问题，包括POJ - 1236的强连通分量缩点、UVA - 796的找桥、POJ - 3694的Tarjan + LCA算法应用，以及如何在不同场景下求解最少添加边的数量。博主强调理解这些概念在图论问题中的重要性，并提供了具体的解题思路。

摘要由CSDN通过智能技术生成

连通图一般来说是比较简单的，但是其变形非常的多，参透其思想是很重要的。关于连通图，比较经典的挑战和紫书上的讲解就已经足够。

POJ - 1236 强连通分量缩点

这道题的题意是有N个学校，每个学校到其他的学校有一条单向的传输路径。题目要求先求出强连通分量的个数。还有一问是至少要添加多少单向边，可以让整个图变成强连通图。

首先我们能想到利用强连通分量来缩点。现在我们假设已经求出了强连通分量，那么第一问就结束了，首先来考虑一下Scc == 1的时候，此时所有的点都可以互相到达，那么就不需要多添加变了。之后我们来考虑一下缩点，我们把每一个连通分量看成一个点,那么这些点肯定无法形成强连通图，我们要让这个突变成强连通图，也就说从任何一点出发，都可以到达其他的点，那么我们来算出所点之后的图出度为0和入度为0的点有多少个，取最大值就行。也就相当于是出度为零的点向入读为0的点连一条边。

#include <cstdio>
#include <cstring>
#include <iostream>
#define ll long long
using namespace std;
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;
int in[MAXN],out[MAXN];
int n;
int scc;//强连通分量的个数
bool Instack[MAXN];
int num[MAXN];//各个强连通分量包含点的个数，数组编号1~scc
//num数组不一定需要，结合实际情况
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if( !DFN[v] )
        {
            Tarjan(v);
            if( Low[u] > Low[v] )
                Low[u] = Low[v];
        }
        else if(Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }
        while( v != u);
    }
}
void solve(int N)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));
    Index = scc = top = 0;
    for(int i = 1; i <= N; i++)
        if(!DFN[i])
            Tarjan(i);
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    for(int i = 1;i<=N;i++)
    {
        for(int j = head[i];j != -1 ;j = edge[j].next)
        {
            int v = edge[j].to;
            if(Belong[v] != Belong[i])
            {
                out[Belong[i]] ++;
                in[Belong[v]] ++;
            }
        }
    }
    int t1 = 0,t2 = 0;
    for(int i = 1;i<=scc;i++)
    {
        if(in[i] == 0) t1++;
        if(out[i] == 0) t2++;
    }
    if(scc == 1)
    {
        printf("1\n0\n");
    }
    else
    {
        printf("%d\n%d\n",t1,max(t1,t2));
    }
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
int main()
{

    while(scanf("%d", &n) != EOF)
    {
        init();
        for(int i = 1; i<=n; i++)
        {
            int x;
            while(1)
            {
                scanf("%d",&x);
                if(x == 0)
                    break;
                addedge(i,x);
            }
        }
        solve(n);

    }
    return 0;
}

这道题不仅仅需要求出来强连通分量，还需要之前求出来的进行缩点，缩点也是图论问题中经常碰到的问题。

找桥 UVA - 796

求桥的裸题，记得要排序输出。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10010;
const int MAXM = 100010;
struct Edge
{
    int to,next;
    bool cut;//是否为桥的标记
} edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN];
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];
int add_block[MAXN];//删除一个点后增加的连通块
int bridge;
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].cut = false;
    head[u] = tot++;
}
void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son = 0;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre)
            continue;
        if( !DFN[v] )
        {
            son++;
            Tarjan(v,u);
            if(Low[u] > Low[v])
                Low[u] = Low[v];
//桥
//一条无向边(u,v)是桥，当且仅当(u,v)为树枝边，且满足DFS(u)<Low(v)。
            if(Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;
            }
//割点
//一个顶点u是割点，当且仅当满足(1)或(2) (1) u为树根，且u有多于一个子树。
//(2) u不为树根，且满足存在(u,v)为树枝边(或称父子边，
//即u为v在搜索树中的父亲)，使得DFS(u)<=Low(v)
            if(u != pre && Low[v] >= DFN[u])//不是树根
            {
                cut[u] = true;
                add_block[u]++;
            }
        }
        else if( Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
//树根，分支数大于1
    if(u == pre && son > 1)
        cut[u] = true;
    if(u == pre)
        add_block[u] = son - 1;
    Instack[u] = false;
    top--;
}
void solve(int N)
{
    memset(DFN,