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 5 2 1 2 4 5 2 4 3 4 2 3 3 2 0 1 2 1 3
輸出樣例
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 因爲我們要求最後的拓撲序列字典序最大，所以一定要貪心地將標號越大的點越早入隊。我們定義點i的入度爲di。假設當前還能刪去k條邊，那麼我們一定會把當前還沒入隊的di≤k的最大的i找出來，把它的di條入邊都刪掉，然後加入拓撲序列。可以證明，這一定是最優的。 具體實現可以用線段樹維護每個位置的di，在線段樹上二分可以找到當前還沒入隊的di≤k的最大的i。於是時間複雜度就是O((n+m)logn). 不過，這裏面說的還有一點不太清楚， 轉一下另一個題解： http://blog.csdn.net/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();
}
}