洛谷 P1954 [NOI2010]航空管制

https://www.luogu.org/problemnew/show/P1954

拓扑排序，

注意到如果正着建图（"a出现早于b"=>"a向b连边"），贪心选择，可能前面某一次的选择造成后面找不出合法方案；

但是如果反过来建图，而且每一次选择当前入度为0的点中K值最大的，那么一定不会产生前面那种情况；因此用堆维护

对于第一问，直接跑一遍即可。。（而且题面还说了一定有可行解）

对于第二问，

设当前要使得now的起飞序号最小，那么就是使得在反着的图的拓扑序遍历中，now被遍历的次序尽量往后排

那么，在遍历到now时，不减小其出边指向的点的入度；不改变拓扑排序的其他流程

这样，如果什么时候堆为空了，或者堆中弹出来的那个节点已经不满足时间限制了，说明这时必须遍历now了

洛谷卡常。。。

手工定义一个pii比pair<int,int>要快200ms+。。不知道为什么（看stl源码，pair<int,int>的逻辑也是很简单的）

 #pragma GCC optimize(3)
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<queue>
 using namespace std;
 #define fi first
 #define se second
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 struct pii
 {
     int fi,se;
     pii(){}
     pii(int a,int b):fi(a),se(b){}
 };
 bool operator<(const pii &a,const pii &b)
 {
     return a.fi<b.fi||(a.fi==b.fi&&a.se<b.se);
 }
 struct E
 {
     int to,nxt;
 }e[];
 int f1[],ne;
 int n,m,K[];
 int inn[],in[],num;
 vector<int> ans;
 struct
 {
     pii d[];
     int tp;
     void clear(){tp=;}
     void push(const pii &x)
     {
         d[tp++]=x;
         push_heap(d,d+tp);
     }
     void pop()    {pop_heap(d,d+tp);--tp;}
     pii top()    {return d[];}
     bool empty(){return tp==;}
 }q;
 template<class T>
 inline void read(T &x) {
     int f=;x=;char ch=getchar();
     while(ch>''||ch<''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x*=;x+=(ch-'');ch=getchar();}
     x*=f;
 }
 template<class T>
 inline void write(T x) {
     if(x<) putchar('-'),x=-x;
     if(x>) write(x/);
     putchar(x%+'');
 }
 int main()
 {
     int i,a,b,u,k;pii t;
     read(n);read(m);
     for(i=;i<=n;i++)    read(K[i]);
     for(i=;i<=m;i++)
     {
         read(a);read(b);
         e[++ne].to=a;e[ne].nxt=f1[b];f1[b]=ne;
         inn[a]++;
     }
     {
         memcpy(in+,inn+,sizeof(int)*n);
         for(i=;i<=n;i++)
             if(!in[i])
                 q.push(pii(K[i],i));
         while(!q.empty())
         {
             t=q.top();q.pop();
             u=t.se;
             ans.pb(u);
             for(k=f1[u];k;k=e[k].nxt)
             {
                 in[e[k].to]--;
                 if(!in[e[k].to])
                     q.push(pii(K[e[k].to],e[k].to));
             }
         }
         for(i=ans.size()-;i>=;i--)
             write(ans[i]),putchar(' ');
         puts("");
     }
     for(int now=;now<=n;now++)
     {
         q.clear();
         num=;
         memcpy(in+,inn+,sizeof(int)*n);
         for(i=;i<=n;i++)
             if(!in[i])
                 q.push(pii(K[i],i));
         while(!q.empty())
         {
             t=q.top();q.pop();
             u=t.se;
             if(n-num>K[u])    break;
             if(u==now)    continue;
             num++;
             for(k=f1[u];k;k=e[k].nxt)
             {
                 in[e[k].to]--;
                 if(!in[e[k].to])
                     q.push(pii(K[e[k].to],e[k].to));
             }
         }
         write(n-num);putchar(' ');
     }
     return ;
 }