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

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

View Code

 1 #include<iostream>
 2 #include<vector>
 3 #include<stack>
 4 const int MAXN=10000+10;
 5 using namespace std;
 6 vector<int>mp[MAXN];
 7 stack<int>S;
 8 int n,m;
 9 int _count;
10 int cnt;
11 bool mark[MAXN];
12 int dfn[MAXN];
13 int low[MAXN];
14 
15 //求强连通分量tarjan
16 void Tarjan(int u){
17     dfn[u]=low[u]=++cnt;
18     mark[u]=true;
19     S.push(u);
20     for(int i=0;i<mp[u].size();i++){
21         int v=mp[u][i];
22         if(dfn[v]==0){
23             Tarjan(v);
24             low[u]=min(low[u],low[v]);
25         }else if(mark[v]&&dfn[v]<low[u]){
26             low[u]=dfn[v];
27         }
28     }
29     if(low[u]==dfn[u]){
30         _count++;
31         int v;
32         do{
33             v=S.top();
34             S.pop();
35             mark[v]=false;
36         }while(u!=v);
37     }
38 }
39 
40         
41 int main(){
42     while(~scanf("%d%d",&n,&m)){
43         if(n==0&&m==0)break;
44         for(int i=1;i<=n;i++)mp[i].clear();
45         for(int i=1;i<=m;i++){
46             int x,y;
47             scanf("%d%d",&x,&y);
48             mp[x].push_back(y);
49         }
50         memset(mark,false,sizeof(mark));
51         memset(dfn,0,sizeof(dfn));
52         memset(low,0,sizeof(low));
53         _count=0;
54         cnt=0;
55         for(int i=1;i<=n;i++){
56             if(dfn[i]==0){
57                 Tarjan(i);
58             }
59         }
60         if(_count>1){
61             printf("No\n");
62         }else
63             printf("Yes\n");
64     }
65     return 0;
66 }

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

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

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

View Code

 1 #include<iostream>
 2 #include<vector>
 3 #include<stack>
 4 const int MAXN=20000+10;
 5 using namespace std;
 6 vector<int>mp[MAXN];
 7 stack<int>S;
 8 bool mark[MAXN];
 9 int dfn[MAXN],low[MAXN];
10 int color[MAXN];//染色
11 int n,m,_count,cnt;
12 int from[MAXN],to[MAXN];
13 
14 
15 //求有向图强连通分量
16 void Tarjan(int u){
17     dfn[u]=low[u]=++cnt;
18     mark[u]=true;
19     S.push(u);
20     for(int i=0;i<mp[u].size();i++){
21         int v=mp[u][i];
22         if(dfn[v]==0){
23             Tarjan(v);
24             low[u]=min(low[u],low[v]);
25         }else if(mark[v]&&dfn[v]<low[u]){
26             low[u]=dfn[v];
27         }
28     }
29     if(low[u]==dfn[u]){
30         _count++;
31         int v;
32         do{
33             v=S.top();
34             S.pop();
35             mark[v]=false;//相当于出栈
36             color[v]=_count;  //缩点，把一个杂乱无章的有向图变成一个有向无环图
37         }while(u!=v);
38     }
39 }
40 
41 int main(){
42     int _case;
43     scanf("%d",&_case);
44     while(_case--){
45         scanf("%d%d",&n,&m);
46         for(int i=1;i<=n;i++)mp[i].clear();
47         for(int i=1;i<=m;i++){
48             int x,y;
49             scanf("%d%d",&x,&y);
50             mp[x].push_back(y);
51         }
52         memset(mark,false,sizeof(mark));
53         memset(dfn,0,sizeof(dfn));
54         memset(low,0,sizeof(low));
55         memset(color,0,sizeof(color));
56         memset(from,0,sizeof(from));
57         memset(to,0,sizeof(to));
58         _count=0,cnt=0;
59         for(int i=1;i<=n;i++){
60             if(dfn[i]==0){
61                 Tarjan(i);
62             }
63         }
64         if(_count==1){
65             printf("0\n");
66             continue;
67         }
68         for(int i=1;i<=n;i++){
69             for(int j=0;j<mp[i].size();j++){
70                 int k=mp[i][j];
71                 if(color[i]!=color[k]){
72                     from[color[i]]++;//标记color[]表示记录的是第几个连通分量
73                     to[color[k]]++;
74                 }
75             }
76         }
77         int in=0,out=0;
78         for(int i=1;i<=_count;i++){
79             if(from[i]==0)out++;//出度为0
80             if(to[i]==0)in++;//入度为0
81         }
82         printf("%d\n",max(in,out));//max(in,out)即为最少需要连的边
83     }
84     return 0;
85 }
86 
87 
88                 
89         
90 
91 
92                 
93             

下面贴一个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);

}