poj 1236+hdu2767 有向图 缩点+看度数（tarjan）

1236题意：一个有向图，1，求至少从几个点出发可以遍历该图，2:，求至少添加多少边，使强连通。而，HDU的只有后面一问。

解;先缩点，第一问只需找所有入度为0的点即可。，第2问，max（入度为0的点，出度为0点）。也写了2个小时。。虽然1A，但是因为细节卡了，不应该。

代码详细说：

#include<iostream>   //0ms 1A poj1236
#include<vector>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
int n;
vector<vector<int> >edges(101);
int visited[101];
int low[101];
int dfn[101];
int ind[101];int outd[101];          //统计出入度
int Strongly_connected_branch[101];  //并为一个强连通，标记为1.2.3...
int num;int times;
stack<int>s;
bool instack[101];
void tarjan(int u)               //dfs
{
    low[u]=dfn[u]=times++;
    instack[u]=1;
    s.push(u);
    int len=edges[u].size();
    for(int i=0;i<len;i++)
    {
        int v=edges[u][i];
        if(visited[v]==0)          //小心细节！
        {
             visited[v]=1;
               tarjan(v);
            if(low[u]>low[v])low[u]=low[v];
        }
        else if(instack[v]&&low[u]>dfn[v])     //有向图，要问是否在栈中，后向边，V为U某个祖先
        {
            low[u]=dfn[v];
        }
    }
    if(dfn[u]==low[u])         //在一个SCC
    {
        num++;int temp;
         do
        {
             temp=s.top();
             instack[temp]=0;
            s.pop();
            Strongly_connected_branch[temp]=num;
        } while(temp!=u);
    }
}
void readin()            //读入数据
{
    scanf("%d",&n);
    int to;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&to);
        while(to!=0)
       {
           edges[i].push_back(to);
           scanf("%d",&to);
       }
    }
}
int ind0,outd0;
void initialize()             //初始化
{
    ind0=outd0=num=times=0;
}
void solve()
{
    for(int i=1;i<=n;i++)        //原图未必连通
       if(visited[i]==0)
        {
            visited[i]=1;
            tarjan(i);
        }
     for(int i=1;i<=n;i++)     //自己思得：枚举所有边，在不同scc中的，这样统计其出入度，缩点只是把所有SCC分开
   {                           //这样统计，出入度为0的肯定没问题，但是是收缩后的图（原图中有几条边SCC间连任连几条）的出入度，
      int len=edges[i].size();
       for(int j=0;j<len;j++)
       {
          int v=edges[i][j];
          if(Strongly_connected_branch[v]!=Strongly_connected_branch[i])
          {
            outd[Strongly_connected_branch[i]]++;
            ind[Strongly_connected_branch[v]]++;
          }
       }
    }
    for(int i=1;i<=num;i++)
    {
        //cout<<"out:"<<outd[i]<<"in:"<<ind[i]<<endl;
       if(outd[i]==0)outd0++;
       if(ind[i]==0)ind0++;
    }
}
int main()
{
   readin();
   initialize();
   solve();
   int max0=outd0;
   if(num==1){printf("1\n0\n");return 0 ;}        //如果原来就强连通，特判
   if(ind0>max0)max0=ind0;
   printf("%d\n%d\n",ind0,max0);
   return 0;
}

#include<iostream>   //hdu 260ms
#include<vector>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
int n;int m;
vector<vector<int> >edges(20001);
int visited[20001];
int low[20001];
int dfn[20001];
int ind[20001];int outd[20001];          //统计出入度
int Strongly_connected_branch[20001];  //并为一个强连通，标记为1.2.3...
int num;int times;
stack<int>s;
bool instack[20001];
void tarjan(int u)
{
    low[u]=dfn[u]=times++;
    instack[u]=1;
    s.push(u);
    int len=edges[u].size();
    for(int i=0;i<len;i++)
    {
        int v=edges[u][i];
        if(visited[v]==0)
        {
             visited[v]=1;
               tarjan(v);
            if(low[u]>low[v])low[u]=low[v];
        }
        else if(instack[v]&&low[u]>dfn[v])     //有向图，要问是否在栈中，后向边，V为U某个祖先
        {
            low[u]=dfn[v];
        }
    }
    if(dfn[u]==low[u])         //在一个SCC
    {
        num++;int temp;
         do
        {
             temp=s.top();
             instack[temp]=0;
            s.pop();
            Strongly_connected_branch[temp]=num;
        } while(temp!=u);
    }
}
void readin()
{
    scanf("%d%d",&n,&m);
    int from,to;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&from,&to);
        edges[from].push_back(to);
    }
}
int ind0,outd0;
void initialize()              //多组数据，必需初始化
{
    ind0=outd0=num=times=0;
    for(int i=0;i<=n;i++)
    {
        instack[i]=low[i]=dfn[i]=visited[i]=ind[i]=outd[i]=0;
        edges[i].clear();
        Strongly_connected_branch[i]=-1;
    }
}
void solve()
{
    for(int i=1;i<=n;i++)
       if(visited[i]==0)
        {
            visited[i]=1;
            tarjan(i);
        }
     for(int i=1;i<=n;i++)     //自己思得：枚举所有边，在不同scc中的，这样统计其出入度，缩点只是把所有SCC分开
   {                           //这样统计，出入度为0的肯定没问题，但是是收缩后的图（原图中有几条边SCC间连任连几条）的出入度，
      int len=edges[i].size();
       for(int j=0;j<len;j++)
       {
          int v=edges[i][j];
          if(Strongly_connected_branch[v]!=Strongly_connected_branch[i])
          {
            outd[Strongly_connected_branch[i]]++;
            ind[Strongly_connected_branch[v]]++;
          }
       }
    }
    for(int i=1;i<=num;i++)
    {
       if(outd[i]==0)outd0++;
       if(ind[i]==0)ind0++;
    }
}
int main()
{
    int tcase;
    scanf("%d",&tcase);
   while(tcase--)
   {
       initialize();
       readin();
       solve();
     int max0=outd0;
   if(num==1){printf("0\n");continue;}
   if(ind0>max0)max0=ind0;
   printf("%d\n",max0);
   }
   return 0;
}