hdu 4857(拓扑排序+反向建图

最新推荐文章于 2024-08-06 11:44:00 发布

SDNUlixianrui

最新推荐文章于 2024-08-06 11:44:00 发布

阅读量296

点赞数

CC 4.0 BY-SA版权

分类专栏：图

本文链接：https://blog.youkuaiyun.com/sdnulixianrui/article/details/79912041

图专栏收录该内容

6 篇文章

订阅专栏

本文解析了HDU-4857逃生问题，通过使用链式前向星存储图的方式，避免了内存和时间的超限问题。文章详细介绍了如何采用拓扑排序和贪心算法来解决这个问题，特别是反向建图的方法，以确保更富有者在满足条件的情况下尽可能排在前面。

G - 逃生 HDU - 4857

糟糕的事情发生啦，现在大家都忙着逃命。但是逃命的通道很窄，大家只能排成一行。

现在有n个人，从1标号到n。同时有一些奇怪的约束条件，每个都形如：a必须在b之前。
同时，社会是不平等的，这些人有的穷有的富。1号最富，2号第二富，以此类推。有钱人就贿赂负责人，所以他们有一些好处。

负责人现在可以安排大家排队的顺序，由于收了好处，所以他要让1号尽量靠前，如果此时还有多种情况，就再让2号尽量靠前，如果还有多种情况，就让3号尽量靠前，以此类推。

那么你就要安排大家的顺序。我们保证一定有解。

Input 第一行一个整数T(1 <= T <= 5),表示测试数据的个数。
然后对于每个测试数据，第一行有两个整数n(1 <= n <= 30000)和m(1 <= m <= 100000)，分别表示人数和约束的个数。

然后m行，每行两个整数a和b，表示有一个约束a号必须在b号之前。a和b必然不同。 Output 对每个测试数据，输出一行排队的顺序，用空格隔开。 Sample Input

Sample Output

1 2 3 4 5

这道题让我知道了，存图的时候最好用链式前向星不容易超内存，也不容易超时。拓扑排序适用于的有向图不一定是连通图。非连通图也能用。

这道题无论是正向建图还是反向建图，运用的思想都是贪心。如果正面贪的话，不能保证最小的在前面。比如两条路径

5 -> 1

3 -> 2

贪心的话会是3 2 5 1但是正确结果是5 1 3 2，题意是满足1尽量靠前的前提下再满足2尽量靠前，正面贪的话无法正确选择带有1的那条路。而反向贪的话，不用确保尽量大的靠后，而是满足尽量小的在前。也就是说每次把入度为0，且数较大的拿走，留下的就应该是数小的。

讲的很好的一篇博客https://blog.youkuaiyun.com/u012861385/article/details/38059515

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>

using namespace std;
const int Max = 30003;
int n, m;
struct cmp
{
    bool operator () (int a, int b)
    {
        return a < b;
    }
};
int indegree[Max];
int ans[Max];
int head[Max];
int cnt;
struct edge
{
    int u;
    int v;
    int next;
}edge[100005];
void add(int u, int v)
{
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].next = head[u];
    head[u] = cnt ++;
}
void init()
{
    memset(indegree, 0, sizeof(indegree));
    memset(ans, 0, sizeof(ans));
    memset(head, -1, sizeof(head));
    memset(edge, 0, sizeof(edge));
    cnt = 0;
}
void topological_sort()
{
    priority_queue<int, vector<int>, cmp> q;
    for(int i = 1; i <= n; i ++)
    {
        if(indegree[i] == 0)
            q.push(i);
    }
  int cnt = 0;
  while(!q.empty())
  {
        int u = q.top();
        q.pop();
        ans[cnt ++] = u;
     for(int i = head[u]; ~i; i = edge[i].next)
     {
             indegree[edge[i].v] --;
             if(!indegree[edge[i].v])
                q.push(edge[i].v);
     }
  }
}
int main()
{
   int t;
   scanf("%d", &t);
   while(t --)
   {
       init();
       scanf("%d %d", &n, &m);
       for(int i = 0; i < m; i ++)
       {
           int u, v;
           scanf("%d %d", &u, &v);
           int flag = 1;
           for(int j = head[u]; ~j; j = edge[j].next)
           {
               if(edge[j].v == v)
                flag = 0;
           }
           if(flag)
            {
                add(v,u);
                indegree[u] ++;
            }
       }
       topological_sort();
       printf("%d", ans[n-1]);
       for(int i = n - 2; i >= 0; i --)
        {
            printf(" %d", ans[i]);
        }
       printf("\n");
   }
    return 0;
}