拓扑排序模板

/*==================================================*\ 
| topoSort -- 使用dfs          
| 使用dfs难以保证topo结果为最小的顺序 
\*==================================================*/  
int n, m, a, b, G[maxn][maxn];    
int c[maxn];                    //0 1 -1 未访问过 已访问过全部孩子 正在访问  
int topo[maxn], t;              //保存结果  
void init()
{
    memset(in,0,sizeof(in));
    memset(topo,0,sizeof(topo));
    for(int i=0;i<maxn;i++)
    {
        G[i].clear();
    }
}
bool dfs(int u) {  
    c[u] = -1;                                  //标记正在访问  
    for(int v = 1; v <= n; ++v) {  
        if(G[u][v]) {  
            if(c[v] < 0) return 0;  
            else if(!c[v] && !dfs(v)) return 0; //递归访问相关点，返回有环的情况   
        }  
    }  
    c[u] = 1;                                   //访问结束  
    topo[t--] = u;                              //记录结果  
    return 1;  
}  
bool topoSort() {  
    t = n; met(c, 0);  
    for(int u = 1; u <= n; ++u) if(!c[u]) {  
        if(!dfs(u)) return 0;  
    }  
    return 1;  
}  
/*==================================================*\ 
| topoSort -- 使用bfs      
\*==================================================*/  
vector<int> G[maxn];  
int in[maxn];           //入度  
int topo[maxn], t;  
void init()
{
    memset(in,0,sizeof(in));
    memset(topo,0,sizeof(topo));
    for(int i=0;i<maxn;i++)
    {
        G[i].clear();
    }
}
bool topoSort() {  
    priority_queue<int, vector<int>, greater<int> > q; t = 0; //优先队列保证最小序列  
    for(int i = 1; i <= n; ++i) {  
        if(in[i] == 0) q.push(i);  
    }  
  
    int cnt = 0;  
    while(!q.empty()) {  
        int u = q.top(); q.pop();  
        topo[t++] = u; ++cnt;  
        for(int v = 0; v < G[u].size(); ++v) {  
            if(--in[G[u][v]] == 0) q.push(G[u][v]);             //找入度为0的边入队  
        }  
    }  
  
    if(cnt != n) return 0;                                      //有环  
    return 1;  
}