【缩点】HDU 2767 Proving Equivalences

最新推荐文章于 2024-09-07 20:24:11 发布

F丶轩

最新推荐文章于 2024-09-07 20:24:11 发布

阅读量412

点赞数

分类专栏： tarjan 文章标签： tarjan 图论缩点

本文链接：https://blog.csdn.net/f_xuan/article/details/38543147

版权

tarjan 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2767

题目要求最少要添几条边使整个图成为强连通图

先用tarjan缩点，

要使缩点后的图成为强连通图，每个顶点最少要有一个入度（其他点连接它）和一个出度（它连接其他点），一条边又提供一个出度和一个入度。
所以可以通过统计没有入度的顶点数 NoInDegree 和没有出度的顶点数 NoOutDegree。

即对于每个缩点，少出度就添，少入度就添；
所需要添加的边数就是NoInDegree和NoOutDegree中的最大值。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 20100
#define M 50100

struct node {
    int to,next;
}edge[M];

int n,m;

int head[N];
int k;

int top;
int Stack[N];
int InStack[N];
int DFN[N];
int Low[N];
int Index;
int Bcnt;
int Belong[N];

int in[N],out[N];
int NoInDegree,NoOutDegree;


void add(int u,int v){
    edge[k].to=v;
    edge[k].next=head[u];
    head[u]=k++;
}

void init(){
    k=1;
    NoInDegree=NoOutDegree=Index=Bcnt=top=0;
    memset(InStack,0,sizeof(InStack));
    memset(DFN,0,sizeof(DFN));
    memset(head,0,sizeof(head));
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
}

void tarjan(int u){
    int i,v;
    DFN[u]=Low[u]=++Index;
    Stack[++top]=u;
    InStack[u]=1;
    for(i=head[u];i;i=edge[i].next){
        v=edge[i].to;
        if(!DFN[v]){
            tarjan(v);
            Low[u]=min(Low[u],Low[v]);
        }else if(InStack[v])
            Low[u]=min(Low[u],DFN[v]);
    }
    if(Low[u]==DFN[u]){
        Bcnt++;
        do{
            v=Stack[top--];
            InStack[v]=0;
            Belong[v]=Bcnt;
        }while(u!=v);
    }
}

int main(){
    int t;
    int i,j;
    int a,b;
    scanf("%d",&t);
    while(t--){
        init();
        scanf("%d%d",&n,&m);
        for(i=0;i<m;++i){
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        for(i=1;i<=n;++i){
            if(!DFN[i])
                tarjan(i);
        }
        for(i=1;i<=n;++i){
            for(j=head[i];j;j=edge[j].next){
                a=Belong[i];
                b=Belong[edge[j].to];
                if(a!=b){
                    in[b]++;
                    out[a]++;
                }
            }
        }
        for(i=1;i<=Bcnt;++i){
            if(in[i]==0)NoInDegree++;
            if(out[i]==0)NoOutDegree++;
        }
        
        if(Bcnt==1){
            printf("0\n");
        }else{
            printf("%d\n",max(NoInDegree,NoOutDegree));
        }
    }
    return 0;
}