HDU 1285 说一道拓扑排序

自从北京赛结束，就很不想碰拓扑，也没有碰拓扑。总觉得是自己一道拓扑废了老长时间，以致我们小队输得很惨。周一的校赛提交题目又很窒息，整个人废了两天，却又突然想开了。

---

---

 

HDU1285 是一道很常规的拓扑排序，模板题。看了下，网上有朋友将各种做法总结在一起，我也照葫芦画瓢一次。

//HDU 1285 拓扑排序
//AC
#include
#include
#include
#include
using namespace std;
int indegree[505];
int mp[505][505];
int ans[505];
int vis[505];
int main()
{
   int n,m;
   while(scanf("%d%d",&n,&m)!=EOF) //EOF 不加会output limit exceeded
   {
       memset(mp,0,sizeof(mp));
       memset(vis,0,sizeof(vis));
       memset(ans,0,sizeof(ans));
       memset(indegree,0,sizeof(indegree));
       int cnt=0;

       for(int i=0;i>a>>b;
           if(!mp[a][b])
           {
               mp[a][b]=1;
               indegree[b]++;
           }
       }

       for(int i=1;i<=n;i++)
       {
           int cur=0;
           for(int j=1;j<=n;j++)
           {
               if(indegree[j]==0 && vis[j]==0 )
               {
                   cur=j;
                   break; // 这个break一定要加上，这是字典序排列的关键
               }
           }

           if(cur==0 && vis[cur]==0)
           {
               ans[cnt++]=i;
               vis[i]=1;
               continue;
           }
            vis[cur]=1;
            ans[cnt++]=cur;

            indegree[cur]=0;
           for(int j=1;j<=n;j++)
           {
               if(mp[cur][j] && cur!=j)
               {
                   indegree[j]--;
               }
           }
       }

       for(int i=0;i

第一个，output limit exceeded的原因是 ，没有在输入函数的后面加 ！=EOF，，哎呀，又想到自己北京赛的热身赛也是没有加。。这种做法就是很直白的思路：

将输入的数据存到图mp中，同时更新入度的数组。在拓扑排序时，首先找到入度为0 的点，接着遍历所有的点，看是不是这个入度为0 的点的邻接点。如果是，那么入度-1。字典序的控制依赖于刚开始的循环。并且，在没有入度为0的仍然按照字典序存入res数组。

注意，这里的WA点，在输入的数据可能会有重复，这时就需要判断是否已经存在，否则indegree[ ]的结果就会出问题了。。感觉自己的北京赛就被坑在这里。

 

第二种，使用优先队列。跟第一种的想法类似。只不过将原来控制字典序的for循环，改成了优先队列而已。但是有一点要注意，就是入度为0时，压入栈之后需要将入度设为-1。因为你每一次找邻接点时，都在遍历，如果不将已经进入栈的节点标记一下，他们永远都有可能再进栈。

//AC
//HDU 1285 拓扑排序
#include
#include
#include
#include
using namespace std;
int mp[505][505];
int indegree[505];
int ans[505];
int m,n;
int topo()
{
    priority_queue,greater > q;
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(indegree[i]==0)
        {
            q.push(i);
            indegree[i]=-1;
        }
    }

    while(!q.empty())
    {
        int top = q.top();
        q.pop();

        ans[cnt++]=top;
        for(int i=1;i<=n;i++)
        {
            if(mp[top][i]&&top!=i)
            {
                indegree[i]--;
            }
            if(indegree[i] == 0 && top!=i)
            {
                q.push(i);
                indegree[i]=-1;
            }
        }
    }

    for(int i=0;i>a>>b;
           if(!mp[a][b])
           {
               mp[a][b]=1;
               indegree[b]++;
           }
       }
        topo();


   }
}

 

第三种，就是纯模板的了。

//AC
//HDU 1285
#include
#include
#include
#include
using namespace std;
int indegree[505];
int ans[505];
int head[505];
const int maxn = 10005;
int cnt;
int cnt2;
int m,n;
struct Node
{
    int to;
    int next;//同一个from点的列表中的  输入的上一个边的序号
}edge[maxn];

void add(int from , int to)
{
    edge[cnt].to = to;
    edge[cnt].next = head[from];
    head[from]=cnt;
    cnt++;
}

void topo()
{
    priority_queue,greater > q;
    for(int i=1;i<=n;i++)
    {
        if(indegree[i]==0)
        {
            q.push(i);
        }
    }

    while(!q.empty())
    {
        int top=q.top();
        q.pop();
        ans[cnt2++]=top;
        for(int j=head[top];j!=-1;j=edge[j].next)
        {

            indegree[edge[j].to]--;
            if(indegree[edge[j].to]==0)
            {
                q.push(edge[j].to);
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&n,&m) != EOF)
   {
       memset(ans,0,sizeof(ans));
       memset(indegree,0,sizeof(indegree));
       memset(head , -1 , sizeof(head));
       cnt=0;
       cnt2=0;
       for(int i=1;i<=m;i++)
       {
           int a,b;
           cin>>a>>b;
           add(a,b);
           indegree[b]++;
       }

        topo();


        for(int i=0;i

该模板记录了每一个节点的邻接边，时间复杂度减少的不是一点点。

这里head[ i ]数组记录的是，第 i 个节点的上一个输入的邻接边的序号。初始化为 -1 ， 表示之前没有输入过。与每个edge[ i ] 的功能类似，只是head[i]存储了最新结果，而edge[  ]数组中每一个结构体中的next，都记录了它对应的上一个邻接边序号

所以，在存入结果ans[ ]数组后 的 删除i节点邻接边的过程中，可以从head[ i ]开始。更新 J 的时候，j=edge[j].next。

应该是这么理解的叭，，，希望有大佬来教教我，抱个大腿子。