hdu 5195 DZY Loves Topological Sorting && BestCoder Round #35

问题描述

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

题解：1.贪心：可以证明：每次找到入度小于等于k的最大节点值，然后将其后继节点的入度减1

   2.然后考虑怎样找到入度小于等于k的最大节点值，可以用线段树，每个节点值维护：该区域节点的入度最小

的值

总结：1.第一步很快想出来了，第二步总想用set来找值未果，结果看到题解提醒才会

   2.沉溺于一个最初的方法没有及时改变思路

   3.养成全面思考问题的习惯，线段树，树状数组，平衡树，多个角度思考，全面枚举找最优数据结构

#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();
    }
}