poj 2367 拓扑排序

题目链接：http://poj.org/problem?id=2367

题目大意：就是进行拓扑排序，先给你一个数n，代表1~n，对于每个数有一系列的指向，最后将这些数进行排列出来。。就是简单的拓扑排序。

首先拓扑排序应该有两种实现的方法。。

一种是用dfs进行每个节点的搜索，最后进行回溯，这样的话很容易就能明白先找出来的应该是后面的数，而最后找出来的应该是之前的数，因为是回溯出来的嘛。。所以可以使用一个栈来进行答案的存储，因为栈的特性就是后压入的先弹出。

dfs实现的思想：利用一个数组来存储每个顶点的状态，-1代表正在栈帧中（也就是还在调用dfs尚未返回），0表示还未进行访问，1表示调用过dfs并已经返回。。

在使用一个二维数组来进行元素之间指向的标记，比如1指向2，就让G[1][2]=1;

实现的方法就是对于每个节点尝试进行dfs，（也就是说如果他未被访问过，则调用dfs），而每个节点进入dfs之后，再找到这个节点所指向的节点，如果不出现环的话，就再对这个节点进行dfs，这样一直下去，直到有一个点没有指向，最后就会将这个点标记为已访问，并且压入储存答案的栈，再返回 true，表示成功进行dfs，之后就会回溯，这样下去就会找到一开始的头节点，因为拓扑排序对每个节点都尝试进行这样的操作，所以最后就可以将其排序出来。

要点：感觉dfs实现的要点就在于标记节点，以及如何判断是否出现环，如果一个节点指向的一个节点的标记为-1，也就是说其还在栈中，那么就可以判断是有环的。

dfs代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
#define M 1000
int vis[M];
int G[M][M];
stack<int> s; //用于储存答案
int n;
bool dfs(int u)
{
    vis[u] = -1;
    for(int i = 1;i <= n;i++)
    {
        if(G[u][i])
        {
            if(vis[i]<0) return false;  //该元素正在调用dfs，意味着有环。。
            if(!vis[i] && !dfs(i)) return false; //如果没有访问过，并且这个节点调用dfs返回false
        }
    }
    vis[u] = 1;  //标记成功调用并返回。
    s.push(u);   //将该节点压入栈中
    return true;
}
bool toposort()
{
    memset(vis,0,sizeof(vis));
    for(int i = 1;i <= n;i++)//遍历每个节点
    {
        if(!vis[i])
        {
            if(!dfs(i)) return false; //有环
        }
    }
    return true;
}
int main()
{
    cin >> n;
    for(int i = 1;i <= n;i++)
    {
        for(;;)
        {
            int temp;
            cin >> temp;
            if(temp == 0) break;    //输入直到0
            G[i][temp] = 1;
        }
    }
    toposort();
    cout << s.top();
    s.pop();
    while(!s.empty())
    {
        cout << " " << s.top(); //格式控制
        s.pop();
    }
    cout <<endl;
    return 0;
}

主要的思想就是用一个数组来存储每个节点的入度，并且用一个vector的数组来存储每一个节点所指向的节点。就可以遍历所有节点，找出入度为一的节点，使其入队，然后再对这个节点所指向的节点遍历，将他们的入度都减1，如果入度变为0，就也进入队列中。对于bfs来说要判断是否有环的话，如果队列中出现的节点的个数小于总共节点的个数，那么一定是出现了环。因为环的话每个节点的入度都为1，没有0的。

还有就是答案因为是正序的所以我们可以用一个队列来存储输出。。

个人感觉还是bfs比较好想一点。。暴露了弱渣的本质orzzzzzzzzzz

bfs代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define M 10000
int s[M]; //in
vector<int> G[M];
int n;
queue<int> ans;
void toposort()
{
    queue<int> q;
    for(int i = 1;i <= n;i++)
    {
        if(s[i]==0)
            q.push(i);
    }
    while(!q.empty())
    {
        int cur = q.front();
        q.pop();
        ans.push(cur);
        for(int i = 0;i < G[cur].size();i++)
        {
            s[G[cur][i]]--;
            if(s[G[cur][i]]==0)
                q.push(G[cur][i]);
        }
    }
}
int main()
{
    cin >> n;
    for(int i = 1;i <= n;i++)
       G[i].clear();
    for(int i = 1;i <= n;i++)
    {
        for(;;)
        {
            int temp ;
            cin >> temp;
            if(temp==0) break;
            s[temp]++;
            G[i].push_back(temp);
        }
    }
    toposort();
    cout << ans.front();
    ans.pop();
    while(!ans.empty())
    {
        cout << " " << ans.front();
        ans.pop();
    }
    cout << endl;
    return 0;
}

poj 2367 拓扑排序

原文：http://blog.csdn.net/liujc_/article/details/44809985