hdu 1269+hdu 2767(强连通分量）

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

#include<iostream>
#include<vector>
#include<stack>
const int MAXN=10000+10;
using namespace std;
vector<int>mp[MAXN];
stack<int>S;
int n,m;
int _count;
int cnt;
bool mark[MAXN];
int dfn[MAXN];
int low[MAXN];

//求强连通分量tarjan
void Tarjan(int u){
    dfn[u]=low[u]=++cnt;
    mark[u]=true;
    S.push(u);
    for(int i=0;i<mp[u].size();i++){
        int v=mp[u][i];
        if(dfn[v]==0){
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(mark[v]&&dfn[v]<low[u]){
            low[u]=dfn[v];
        }
    }
    if(low[u]==dfn[u]){
        _count++;
        int v;
        do{
            v=S.top();
            S.pop();
            mark[v]=false;
        }while(u!=v);
    }
}

        
int main(){
    while(~scanf("%d%d",&n,&m)){
        if(n==0&&m==0)break;
        for(int i=1;i<=n;i++)mp[i].clear();
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x].push_back(y);
        }
        memset(mark,false,sizeof(mark));
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        _count=0;
        cnt=0;
        for(int i=1;i<=n;i++){
            if(dfn[i]==0){
                Tarjan(i);
            }
        }
        if(_count>1){
            printf("No\n");
        }else
            printf("Yes\n");
    }
    return 0;
}

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

思路：可以用tarjan算法求出求出有向图的强连通分量，并进行染色，然后在缩点，缩点的好处就是把原本杂乱的有向图变成有向无环图。。。

然后统计入度为0的点和出度为0的点，取其较大值就是所求的要求添加的最少的边的条数了。

#include<iostream>
#include<vector>
#include<stack>
const int MAXN=20000+10;
using namespace std;
vector<int>mp[MAXN];
stack<int>S;
bool mark[MAXN];
int dfn[MAXN],low[MAXN];
int color[MAXN];//染色
int n,m,_count,cnt;
int from[MAXN],to[MAXN];


//求有向图强连通分量
void Tarjan(int u){
    dfn[u]=low[u]=++cnt;
    mark[u]=true;
    S.push(u);
    for(int i=0;i<mp[u].size();i++){
        int v=mp[u][i];
        if(dfn[v]==0){
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(mark[v]&&dfn[v]<low[u]){
            low[u]=dfn[v];
        }
    }
    if(low[u]==dfn[u]){
        _count++;
        int v;
        do{
            v=S.top();
            S.pop();
            mark[v]=false;//相当于出栈
            color[v]=_count;  //缩点，把一个杂乱无章的有向图变成一个有向无环图
        }while(u!=v);
    }
}

int main(){
    int _case;
    scanf("%d",&_case);
    while(_case--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)mp[i].clear();
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x].push_back(y);
        }
        memset(mark,false,sizeof(mark));
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(color,0,sizeof(color));
        memset(from,0,sizeof(from));
        memset(to,0,sizeof(to));
        _count=0,cnt=0;
        for(int i=1;i<=n;i++){
            if(dfn[i]==0){
                Tarjan(i);
            }
        }
        if(_count==1){
            printf("0\n");
            continue;
        }
        for(int i=1;i<=n;i++){
            for(int j=0;j<mp[i].size();j++){
                int k=mp[i][j];
                if(color[i]!=color[k]){
                    from[color[i]]++;//标记color[]表示记录的是第几个连通分量
                    to[color[k]]++;
                }
            }
        }
        int in=0,out=0;
        for(int i=1;i<=_count;i++){
            if(from[i]==0)out++;//出度为0
            if(to[i]==0)in++;//入度为0
        }
        printf("%d\n",max(in,out));//max(in,out)即为最少需要连的边
    }
    return 0;
}


                
        


                
            

下面贴一个tarjan的算法流程：

tarjan（u）

{

　　dfn[u]=low[u]=++cnt;

　　Stack.push(u)

　　for(each(u,v) in E)

　　　　if(v is not visited)

　　　　　　tarjan(v);

　　　　　　low[u]=min(low[u],low[v]);

　　　　else if(v is in Stack)

　　　　　　low[u]=min(low[u],dfn[v]);

　　if(dfn[u]==low[u])

　　　　repeat

　　　　　　v=Stack.pop

　　　　　　print v

　　　　until(u==v);

}