ZOJ_3795 Grouping(强连通分量 拓扑)

题目请点我
题解：
这是我的第一道强连通分量，虽然参考了别人的代码，还是很有收获。强连通分量的查找和处理是很多图论题目的第一步，所以还是很重要，这道题只是有向图的强连通处理。
这道题因为题目有讲每组关系都是不小于，那么如果出现环的话那只有一种情况，就是环上所有人都是相等的年龄，则这个环上所有的人的比较关系都是可以等价的，这就是为什么我们要先对强连通分量尽行缩点处理，将每一个强连通分量作为一个整体,之后再依据层次关系构造拓扑序，利用拓扑序找到最长的一条序列。
算法讲解
代码参考
测试数据：

4 4
1 2
2 3
3 4
4 1

5 3
1 2
2 3
3 4

9 9
5 4
4 1
1 3
3 2
2 1
1 6
6 7
7 8
8 9

5 5
1 2
2 3
3 4
4 1
5 1

代码实现：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <limits.h>
#include <queue>
#define MAX_N 100010
#define MAX_M 300010

using namespace std;

struct E{
    int from,to,next;
    bool sign;
};
int N,M;
int result;
int edgenum;//边的数目
int top,cnt,Time;//栈顶，强联通分量数目，时间轴
E edge[MAX_M];//边集
int dis[MAX_N];//拓扑序中节点的权值
int head[MAX_N];//前向星存储head数组
int belong[MAX_N];//记录某个点属于哪一个强连通分量
int indegree[MAX_N];//记录拓扑序中强连通分量入度
bool instack[MAX_N];//节点是否入栈
int DFN[MAX_N];//节点u搜索的次序编号（时间戳）
int Low[MAX_N];//节点u或u的子树能追溯到的最早的栈中节点的次序号
int Stack[MAX_N];//手写栈
vector<int> G[MAX_N];//存储拓扑序
vector<int> bcnt[MAX_N];//存储每一个强连通分量
void add(int u,int v);//前向星加边
void tarjan(int u);//查找强连通分量
void tarjan_ini(int all);
void suodian();//缩点函数，按照每个强连通分量构造拓扑序
int bfs();

int main(){
    //freopen("in.txt","r",stdin);
    while( scanf("%d%d",&N,&M) != EOF ){
        int a,b;
        edgenum = 0;
        memset(head,-1,sizeof(head));
        while( M-- ){
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        tarjan_ini(N);
        suodian();
        result = bfs();
        printf("%d\n",result);
    }
    return 0;
}


void tarjan_ini(int all){
    memset(DFN,-1,sizeof(DFN));
    //初始化三个指针
    top = Time = cnt = 0;
    for( int i = 1; i <= all; i++ ){
        //查找每一个未被遍历的点的强连通分量
        if( DFN[i] == -1 ){
            tarjan(i);
        }
    }
}

//递归查找强连通分量
void tarjan(int u){
    //标记时间戳
    DFN[u] = Low[u] = ++Time;
    //入栈，注意这里的前++
    Stack[++top] = u;
    instack[u] = true;

    //查找所有与u相邻边，寻找强连通分量
    for( int i = head[u]; i != -1; i = edge[i].next ){
        E tmp = edge[i];
        //未被访问节点
        if( DFN[tmp.to] == -1 ){
            tarjan(tmp.to);
            //u或u的子树所能追溯到的最早的栈中节点
            Low[u] = min(Low[u],Low[tmp.to]);
        }
        //已被访问且仍在栈中节点
        else if( instack[tmp.to] ){
            Low[u] = min(Low[u],DFN[tmp.to]);
        }
    }
    //u为强连通分量节点，弹栈，所有元素存储到一个vector数组
    if( DFN[u] == Low[u] ){
        int now;
        cnt++;
        bcnt[cnt].clear();
        do{
            //弹栈，注意这里的后--
            now = Stack[top--];
            //标记属于哪一个强连通分量
            belong[now] = cnt;
            instack[now] = false;
            bcnt[cnt].push_back(now);
        }while( now != u );//弹到根节点截止
    }
}

void suodian(){
    for( int i = 1; i <= cnt; i++ ){
        G[i].clear();
        indegree[i] = 0;
    }
    //利用所有不在某一个强连通分量内部的边构造拓扑序
    for( int i = 0; i < edgenum; i++ ){
        int u,v;
        u = belong[edge[i].from];
        v = belong[edge[i].to];
        if( u != v ){
            indegree[v]++;
            G[u].push_back(v);
        }
    }
}

void add(int u,int v){
    E tmp = {u,v,head[u],false};
    edge[edgenum] = tmp;
    head[u] = edgenum++;
}

int bfs(){
    int tmp;
    queue<int> Q;
    for( int i = 1; i <= cnt; i++ ){
        if( indegree[i] == 0 ){
            Q.push(i);
            //初始权值为强连通分量的size
            dis[i] = bcnt[i].size();
        }
        else{
            dis[i] = 0;
        }
    }
    while( !Q.empty() ){
        int u = Q.front();
        Q.pop();
        int len = G[u].size();
        for( int i = 0; i < len; i++ ){
            int v = G[u][i];
            //叠加找到最大权值
            dis[v] = max(dis[v],(int)bcnt[v].size()+dis[u]);
            //若该图为一个强连通图，不会进入这里更新
            //tmp = max(tmp,dis[v]);
            indegree[v]--;
            if( indegree[v] == 0 ){
                Q.push(v);
            }
        }
    }
    //得到结果
    tmp = 1;
    for( int i = 1; i <= cnt; i++ ){
        tmp = max(tmp,dis[i]);
    }
    return tmp;
}