POJ3687 Labeling Balls（拓扑排序\贪心+Floyd）

题目是要给n个重量1到n的球编号，有一些约束条件：编号A的球重量要小于编号B的重量，最后就是要输出字典序最小的从1到n各个编号的球的重量。

正向拓扑排序，取最小编号给最小编号是不行的，不举出个例子真的很难理解= =比如这个数据：

1

4 2

4 1

3 2

正确答案是2 4 3 1，会得到的错误答案是4 2 1 3。

一开始我是用了贪心的做法，每次选未安排重量的最小的编号，安排给它尽量小的重量。某个编号能得到的最小的重量的计算是这样的：

• 计算出约束中重量要小于此编号的编号个数，记为k，这个可以先用Floyd预处理出任意两点间的连通性然后遍历一遍统计
• 因而这个编号能得到的最小重量就是第k个还没被用的重量
• 这时候还要回溯把所有约束中重量要小于到这个编号的编号给他们安排上k-1个重量

见代码：

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 bool map[][];
 int n,m;
 bool floyd(){
     for(int k=; k<=n; ++k){
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j){
                 map[i][j]|=(map[i][k]&map[k][j]);
             }
         }
     }
     for(int i=; i<=n; ++i) if(map[i][i]) return ;
     return ;
 }
 bool vis[];
 int getk(int k){
     for(int i=; i<=n; ++i){
         if(!vis[i]) if(--k==) return i;
     }
     return ;
 }
 int d[];
 void dfs(int u){
     if(d[u]) return;
     int cnt=;
     for(int v=; v<=n; ++v){
         if(map[v][u] && !d[v]) ++cnt;
     }
     d[u]=getk(cnt+);
     vis[d[u]]=;
     for(int v=; v<=n ;++v){
         if(map[v][u]) dfs(v);
     }
 }
 int main(){
     int t,a,b;
     scanf("%d",&t);
     while(t--){
         memset(d,,sizeof(d));
         memset(map,,sizeof(map));
         memset(vis,,sizeof(vis));
         scanf("%d%d",&n,&m);
         while(m--){
             scanf("%d%d",&a,&b);
             map[a][b]=;
         }
         if(!floyd()){
             puts("-1");
             continue;
         }
         for(int i=; i<=n; ++i){
             dfs(i);
             printf("%d ",d[i]);
         }
         putchar('\n');
     }
     return ;
 }

事实上这题正解是反着进行拓扑排序，就是逆图中进行拓扑排序，取最大编号给最大重量。

正确性我是这么理解的：

当前安排的编号是x，有两个入度0的结点a和b，且a<b，按算法是给b球编号x。

反证法，假设给a球编号x能更优，那么

Case b: ...[ ]...[ ]...[x] [ ]... （weight[b]=x）

Case a: ...[y]...[x]...[ ] [ ]... （weight[a]=x）

在后面编号的安排中，就存在一个小于x的编号y被安排在了(Case a)中a的前面，且(Case b)不能做到字典序更小的。但这是不存在的，因为(Case b)马上就能把x-1这个编号安排在a位置，即weight[a]=x-1，这样(Case a)能做的(Case b)也能做了，且(Case b)编号还更小。

所以，选择b编号x比a编号x更优。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 using namespace std;
 #define MAXN 222
 #define MAXM 44444
 struct Edge{
     int u,v,next;
 }edge[MAXM];
 int NE,head[MAXN];
 void addEdge(int u,int v){
     edge[NE].u=u; edge[NE].v=v; edge[NE].next=head[u];
     head[u]=NE++;
 }
 int deg[MAXN],size[MAXN];
 bool toposort(int n){
     priority_queue<int> que;
     for(int i=; i<=n; ++i){
         if(deg[i]==) que.push(i);
     }
     for(int k=n; k>=; --k){
         if(que.empty()) return ;
         int u=que.top(); que.pop();
         size[u]=k;
         for(int i=head[u]; i!=-; i=edge[i].next){
             int v=edge[i].v;
             if(--deg[v]==) que.push(v);
         }
     }
     return ;
 }
 int main(){
     int t,n,m,a,b;
     scanf("%d",&t);
     while(t--){
         NE=;
         memset(head,-,sizeof(head));
         memset(deg,,sizeof(deg));
         scanf("%d%d",&n,&m);
         while(m--){
             scanf("%d%d",&a,&b);
             addEdge(b,a);
             ++deg[a];
         }
         if(toposort(n)){
             for(int i=; i<=n; ++i) printf("%d ",size[i]);
             putchar('\n');
         }else puts("-1");
     }
     return ;
 }