Labeling Balls(变种拓扑)

Labeling Balls

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 20   Accepted Submission(s) : 10

Problem Description

Windy has N balls of distinct weights from 1 unit to N units. Now he tries to label them with 1 to N in such a way that:

1. No two balls share the same label.
2. The labeling satisfies several constrains like "The ball labeled with a is lighter than the one labeled with b".

Can you help windy to find a solution?

 

Input

The first line of input is the number of test case. The first line of each test case contains two integers, N (1 ≤ N ≤ 200) and M (0 ≤ M ≤ 40,000). The next M line each contain two integers a and b indicating the ball labeled with a must be lighter than the one labeled with b. (1 ≤ a, b ≤ N) There is a blank line before each test case.

 

Output

For each test case output on a single line the balls' weights from label 1 to label N. If several solutions exist, you should output the one with the smallest weight for label 1, then with the smallest weight for label 2, then with the smallest weight for label 3 and so on... If no solution exists, output -1 instead.

 

Sample Input

5

4 0

4 1
1 1

4 2
1 2
2 1

4 1
2 1

4 1
3 2

 

Sample Output

1 2 3 4
-1
-1
2 1 3 4
1 3 2 4

 

Source

PKU

前言：纠结了好久的一道题目，缘于题目的意思不够明白；

（PS：一开始以为编号是乱序的，告诉你a编号和b编号的轻重关系，让你求全部编号的轻重的拓扑关系、、、

　　其实，编号已经是固定好的从左往右分别是1~N编号）

　　1，输入的a，b表示编号a的球比编号b的球轻（j既为a位置的球比b位置的球轻）；

　　2，输出的是，依次出编号1~N编号的球的重量。（既为位置1~N球的重量，囧囧囧、、、、）

　　3，注意输出要求的这一句话：

　　　　　“ you should output the one with the smallest weight for label 1, then with the smallest weight for label 2, 　　　　　　　　then with the smallest weight for label 3 and so on...”，意思既为：编号1的球尽可能的轻，编号2的球尽可能轻...　　　    优先级是从编号小道编号大。也就是说，输出的重量，尽可能的吧重量比较小的放在前面。

　　4，如果之间采用正向的拓扑是不可行的，因为正向拓扑的话，既为把这些编号看出是重量，然后从1~N依次获取　　（入度为0且字典序最小的点）因为其求出来的是按照字典序的顺序求的，这样求解方式并不是正常的，

　　　　好比如测试样例子：

　　　　　　5 4

　　　　　　1 4

　　　　　　4 2

　　　　　　5 3

　　　　　　3 2

　　　　你用正向的拓扑求出来的结果会是：1 4 5 3 2，你会发现 这个样例并没有满足最后一组要求(3 2)=>第三个位置　　　　的球的重量要小于第二个位置球的重量，这样求解出来的结果便是错误的了。

　　　　我看要求的是编号从小到大（1~N）的重量，且希望编号越小的球的重量也越小，也就是说，重量越大的球的　　　  尽量赋给编号比较大的球。按照这个思路，我们这样就可以用反向拓扑来实现（其实就是箭头反向），只需要

　　　　对正向拓扑进行一些修改即可，详细修改点请看代码二：

　　　　　　　　　　　　　　

题目大意：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXN 205
int InD[205];
int Edge[205][205];
void MakeSet(int Len)
{
    int i;
    for(i=0;i<=Len;i++)
        InD[i]=0;
    return;
}
int ToPoSort(int n,int* ret)
{
    int i,j,k;
    for(j=n;j>=1;j--)
    {
        for(i=n;i>=1;i--)
            if(InD[i]==0)
            {
                InD[i]--;
                ret[i]=j;
                for(k=1;k<=n;k++)
                    if(Edge[i][k]==1)
                        InD[k]--;
                break;
            }
        if(i<1)break;
    }
    if(j<=0)
        return 1;
    else
        return 0;
}

int main()
{
    int N,M,i,a,b,ID[205],T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        MakeSet(N);
        memset(Edge,0,sizeof(Edge));
        memset(ID,0,sizeof(ID));
        for(i=0;i<M;i++)
        {
            scanf("%d%d",&a,&b);
            if(Edge[b][a]==0)
            {
                Edge[b][a]=1;
                InD[a]++;
            }
        }
        if(ToPoSort(N,ID))
        {
            for(i=1;i<=N;i++)
            {
                printf("%d",ID[i]);
                if(i!=N)putchar(32);
            }
            putchar(10);
        }
        else
            printf("-1
");
    }
    return 0;
}

 修改：2015.2.28（邻接表）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <map>
using namespace std;
#define MAX 215
int InD[MAX];/*InD[i]记录点i的入度*/
int First[MAX];/*First[i]头结点的第一条边的编号*/
struct edge
{
    int TO;/*点*/
    int Next;/*下一条边的编号*/
}ID[MAX*MAX];      /*边表,无向图的边数记得多弄些*/
int SIGN; /*链表的边数，链表的边数=无向图边数*2=有向图边数*/
void Add_E(int x,int y)/*添加点+更新入度操作*/
{
    ID[SIGN].TO=y;
    InD[y]++;
    ID[SIGN].Next=First[x];
    First[x]=SIGN++;
}
int Jude(int x,int y)/*查找与X是否与Y相连，是0，否1*/
{
    int i;
    for(i=First[x];i!=0;i=ID[i].Next)   //查找与该点相关的点
    {
       if(ID[i].TO==y)return 0;
    }
    return 1;
}
int ToPoSort(int N,int Num[])/*能够排序返回1，否则返回0*/
{/*N为点的个数（1~N），Num[]用来存储排序后的结果*/
    int i,j,k;
    for(j=N;j>=1;j--)/*修改点一: j作为重量，重量从大到小依次赋值*/
    {
        for(i=N;i>=1;i--)/*修改点二: i作为编号，编号从大到小查找*/
        {
            if(InD[i]==0)/*找到符合的编号。进行赋值*/
            {
                InD[i]--;
                Num[i]=j;/*修改点三: j作为重量，i作为编号（位置）*/
                for(k=First[i];k!=0;k=ID[k].Next)
                {
                    InD[ID[k].TO]--;
                }
                break;
            }
        }
        if(i<1)break;/*如果全部找完，没有找到，退出*/
    }
    if(j<=0)return 1;/*如果重量能够全部赋值，既可行*/
    else return 0;  /*反正不可行。*/
}
int main()
{
    int M,N,i,T;
    int Num[MAX];
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        int a,b;
        for(i=1;i<=N;i++){First[i]=0;InD[i]=0;}
        for(i=0,SIGN=1;i<M;i++)
        {
            scanf("%d%d",&a,&b);
            if(Jude(b,a))   /*判断重边*/
            {
                Add_E(b,a);
            }
        }
        if(ToPoSort(N,Num))
        {
            for(i=1;i<=N;i++)
            {
                if(i!=1)putchar(32);
                printf("%d",Num[i]);
            }putchar(10);
        }
        else printf("-1
");
    }
    return 0;
}

/*
4
5 4
1 4
4 2
5 3
3 2

5 3
1 4
4 2
3 5

5 4
5 1
4 2
1 3
2 3

10 5
4 1
8 1
7 8
4 1
2 8
ans:
1 5 3 4 2
1 3 4 2 5
2 4 5 3 1        逆向建图
5 1 6 2 7 8 3 4 9 10  没有判重边的话就输出 -1

*/