（拓扑排序）DZY Loves Topological Sorting_输出字典序最大的拓扑排序-优快云博客

本文链接：https://blog.youkuaiyun.com/better_life30/article/details/45014689

DZY Loves Topological Sorting

Accepts: 112

Submissions: 586

Time Limit: 4000/2000 MS (Java/Others)

Memory Limit: 131072/131072 K (Java/Others)

问题描述

一张有向图的拓扑序列是图中点的一个排列，满足对于图中的每条有向边
   
   
    
    (u→v)
   
    从 
   
   
    
    u
   
    到 
   
   
    
    v
   
   ，都满足
   
   
    
    u
   
   在排列中出现在
   
   
    
    v
   
   之前。
现在，DZY有一张有向无环图(DAG)。你要在最多删去
   
   
    
    k
   
   条边之后，求出字典序最大的拓扑序列。

输入描述

输入有多组数据。 (
   
   
    
    TestCase≤5
   
   )
第一行，三个正整数 
   
   
    
    n,m,k(1≤n,m≤105,0≤k≤m)
   
   .
接下来
   
   
    
    m
   
   行，每行两个正整数 
   
   
    
    u,v(u≠v,1≤u,v≤n)
   
   , 代表一条有向边
   
   
    
    (u→v)
   
   .

输出描述

对于每组测试数据，输出一行字典序最大的拓扑序列。

输入样例

输出样例

5 3 1 2 4
1 3 2

Hint

数据1. 删除(2->3),(4->5)两条边，可以得到字典序最大的拓扑序列：(5,3,1,2,4).

（其实都写了一下，懒，转载了）

转自：http://www.cnblogs.com/njczy2010/p/4375234.html

先转官方题解：

http://bestcoder.hdu.edu.cn/

Problem B - DZY Loves Topological Sorting
因为我们要求最后的拓扑序列字典序最大，所以一定要贪心地将标号越大的点越早入队。我们定义点
不过，这里面说的还有一点不太清楚，
转一下另一个题解：
http://blog.youkuaiyun.com/glqac/article/details/44710897

看题意以为是个拓扑排序。事实上，就是个线段树。因为最多可以删k条边，所以就是在线段树里找入度小于等于k的最大值，那么保存个区间最小就ok了。如果右子树的区间最小小于等于k那么就往右边走，因为是要找字典序最大的。当k是0，也是这样找，就跟topological sort是一样的。然后删除一个点就在线段树那个点置最大值，再删除他的边。因为总共也就m条边不超过10^5。

总复杂度o(n+m)logn。

我的解法：

用优先队列，当前节点的入度小于k便入队列，出队列时以节点编号为优先权，如果小于等于k，则输出，反之，跳过。不过写的时候遇到几个问题：

1.节点重复入队列没事，但是，不能让已经在队列中的再入队列。故要用vis，vis=0暂时不在队列中，vis=-1，在队列中，vis=1，已经输出。

2.判断队首元素的入度是否小于k时，要用现在的入度，而不是入队列时的入度，因为，可能在处理其它点的时候，该点的入度已经发生了变化。

总的来说，还是线段树的方法思路清晰~~

优先队列解法：

<pre name="code" class="cpp">#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 100005;
typedef long long LL;
const int INF = 0xfffffff;
int N, M, K;
int r[maxn];
int vis[maxn];
vector<int> ans;
vector<int> bian[maxn];
struct NODE{
	int index;
	int r;
	friend bool operator<(NODE a, NODE b)
	{
		return a.index < b.index;
	}
};
void init()
{
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= N; i++)
	{
		bian[i].clear();
		r[i] = 0;
	}
}
void toposort()
{
	priority_queue<NODE> q;
	while (!q.empty())	q.pop();
	for (int i = N; i >= 1; i--)
	{
		if (r[i] <= K)
		{
			NODE t;
			t.index = i;
			t.r = r[i];
			q.push(t);
			vis[t.index] = -1;
		}
	}
	ans.clear();
	while (!q.empty())
	{
		NODE u = q.top();	q.pop();
		if (u.r<= K)
		{
			vis[u.index] = 1;
			K -= u.r;
		}
		else
		{
			vis[u.index] = 0;
			continue;
		}

		ans.push_back(u.index);
		for (int i = 0; i < bian[u.index].size(); i++)
		{
			int v = bian[u.index][i];
			r[v]--;
			if (r[v] <= K&&vis[v] == 0)
			{
				NODE t;
				t.index = v;
				t.r = r[v];
				q.push(t);
				vis[v] = -1;
			}
		}
	}
}
int main()
{
	//freopen("f:\\input.txt", "r", stdin);
	while (~scanf("%d%d%d",&N,&M,&K))
	{
		init();
		for (int i = 1; i <= M; i++)
		{
			int u, v;
			scanf("%d%d", &u, &v);
			bian[u].push_back(v);
			r[v]++;
		}
		toposort();

		for (int i = 0; i < ans.size() - 1; i++)
			printf("%d ", ans[i]);
		printf("%d\n", ans[ans.size() - 1]);
	}
	return 0;
}

线段树解法：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
#define MAXN 100005
#define lson l,mid,cnt << 1
#define rson mid + 1,r,cnt << 1 | 1
vector<int>vec[MAXN];
int in[MAXN],minn[MAXN << 2],n,m,k;
void build(int l,int r,int cnt)
{
    if(l == r)
    {
        minn[cnt] = in[l];
        return;
    }
    int mid = l + r >> 1;
    build(lson) , build(rson);
    minn[cnt] = min(minn[cnt << 1],minn[cnt << 1 | 1]);
}
int query(int l,int r,int cnt)
{
    if(l == r)return l;
    int mid = l + r >> 1;
    if(minn[cnt << 1 | 1] <= k)return query(rson);
    else return query(lson);
}
void modify(int l,int r,int cnt,int ind,int key)
{
    if(l == r && l == ind)
    {
        minn[cnt] += key;
        return;
    }
    int mid = l + r >> 1;
    if(ind <= mid)modify(lson,ind,key);
    else modify(rson,ind,key);
    minn[cnt] = min(minn[cnt << 1],minn[cnt << 1 | 1]);
}
void solve()
{
    build(1,n,1);
    for(int i = 0;i < n;i++)
    {
        int u = query(1,n,1);
        k -= in[u];
        modify(1,n,1,u,MAXN);
        for(int i = 0;i < vec[u].size();i++)
        {
            int v = vec[u][i];
            in[v]--;
            modify(1,n,1,v,-1);
        }
        if(i != n - 1)printf("%d ",u);
        else printf("%d\n",u);
    }
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&k) != EOF)
    {
        memset(in,0,sizeof(in));
        for(int i = 1;i <= n;i++)vec[i].clear();
        for(int i = 0;i < m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            vec[u].push_back(v);
            in[v]++;
        }
        solve();
    }
}