HDU 1285 说一道拓扑排序

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


HDU 1285 说一道拓扑排序_第1张图片


 

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。

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

HDU 1285 说一道拓扑排序_第2张图片

你可能感兴趣的:(#,HDU,#,图论)