Frogs' Neighborhood

Frogs' Neighborhood

Time Limit : 10000/5000ms (Java/Other)   Memory Limit : 20000/10000K (Java/Other)

Total Submission(s) : 27   Accepted Submission(s) : 17

Special Judge

Problem Description

未名湖附近共有N个大小湖泊L₁, L₂, ..., L_n(其中包括未名湖)，每个湖泊L_i里住着一只青蛙F_i(1 ≤ i ≤ N)。如果湖泊L_i和L_j之间有水路相连，则青蛙F_i和F_j互称为邻居。现在已知每只青蛙的邻居数目x₁, x₂, ..., x_n，请你给出每两个湖泊之间的相连关系。

 

 

Input

第一行是测试数据的组数T(0 ≤ T ≤ 20)。每组数据包括两行，第一行是整数N(2 < N < 10)，第二行是N个整数，x₁, x₂,..., x_n(0 ≤ x_i ≤ N)。

 

 

Output

对输入的每组测试数据，如果不存在可能的相连关系，输出"NO"。否则输出"YES"，并用N×N的矩阵表示湖泊间的相邻关系，即如果湖泊i与湖泊j之间有水路相连，则第i行的第j个数字为1，否则为0。每两个数字之间输出一个空格。如果存在多种可能，只需给出一种符合条件的情形。相邻两组测试数据之间输出一个空行。

 

 

Sample Input

3

7

4 3 1 5 4 2 1

6

4 3 1 4 2 0

6

2 3 1 1 2 1

 

Sample Output

YES
0 1 0 1 1 0 1
1 0 0 1 1 0 0
0 0 0 1 0 0 0
1 1 1 0 1 1 0
1 1 0 1 0 1 0
0 0 0 1 1 0 0
1 0 0 0 0 0 0

NO

YES
0 1 0 0 1 0
1 0 0 1 1 0
0 0 0 0 0 1
0 1 0 0 0 0
1 1 0 0 0 0
0 0 1 0 0 0

 

 

 

第一行输入数据T，表示有T组测试数据； 每一组测试样例，先输入一个数据N，代表有N个顶点， 然后依次输入，代表1~N每个顶点所对应的度数。

这道题其实和就是给你N个顶点，并且告诉你每一个顶点的度是多少，然后让你构建该无向图的关联矩阵而已。如果能够该顶点能够构成无向图，先输出YES,

然后打印出其所对应的关联矩阵，反之，只输出NO。（在每一个测试样例中有一个空行） 我的做法是，用一个结构体记录每一个顶点的编号，并且记录该顶

点的度数。然后，对于这些顶点，对他们的度数的大小进行排序，把最大度数的顶点拿出来和其他顶点连接（依度数从大到小连接，每个顶点只能和最大度数

的顶点连接一次），每连接一个顶点，该顶点和所连接的顶点其所对应的度数减一，直到最大度数的顶点变为0，即为没有顶点与之连接，对应的把其所关联的

的顶点上映射到无向图的关联矩阵上。然后，再次重新根据度数的大小排序，重复操作，直至全部度数为0，便是所求答案。如果，过程中有度数出现0的话，

就说明无法构建成无向图，只需要输出NO。

详情请见代码：

 

 第一次代码：

 1 #include
 2 #include<string.h>
 3 #include 
 4 int Map[12][12];
 5 typedef struct
 6 {
 7     int Data;/*顶点的度数*/
 8     int SUM;/*顶点的编号*/
 9 }NUM;
10 NUM ID[20];
11 
12 int comp(const void *a,const void  *b)/*降序快排的函数调用*/
13 {
14     return ((NUM*)b)->Data-((NUM*)a)->Data;
15 }
16 int main()
17 {
18     int T,i,N,ii,j,jj,SIGN;
19     scanf("%d",&T);
20     while(T--)
21     {
22         memset(Map,0,sizeof(Map));
23         scanf("%d",&N);
24         for(i=0;i)
25         {
26             scanf("%d",&ID[i].Data);/*记录每一个顶点的度数*/
27             ID[i].SUM=i;            /*以及顶点的编号*/
28         }
29         for(i=0,SIGN=1;i)
30         {
31             qsort(ID, N, sizeof(NUM), comp);/*调用快排*/
32             /*putchar(10);              
33             for(ii=0;ii34                 printf("%d ",ID[ii].SUM);
35             putchar(10);
36             for(ii=0;ii37                 printf("%d ",ID[ii].Data);
38             putchar(10);
39             getch();*/
40             if(ID[0].Data==0||SIGN==0)break;/*当最大度数为0，说明全部排序完成，或者存在度数为负的情况跳出*/
41             for(j=1;j<=ID[0].Data;j++)/*映射无向图的关联矩阵*/
42             {
43                 Map[ID[0].SUM][ID[j].SUM]=1;
44                 Map[ID[j].SUM][ID[0].SUM]=1;
45                 if(ID[j].Data-1>=0) 
46                     ID[j].Data--;
47                 else
48                     SIGN=0;/*如果度数小于0，说明无法构成无向图*/
49             }
50             ID[0].Data=0;/*最大度的节点，变成0*/
51             /*putchar('\n');
52             for(ii=0;ii53             {
54                 for(jj=0;jj55                     printf("%d ",Map[ii][jj]);
56                 putchar('\n');
57             }*/
58         }
59         if(SIGN==1)
60         {
61             printf("YES\n");
62             for(ii=0;ii/*输出无向图的关联矩阵*/
63             {
64                 for(jj=0;jj)
65                     printf("%d ",Map[ii][jj]);
66                 putchar('\n');
67             }
68         }
69         else
70             printf("NO\n");
71         putchar(10);
72     }
73 
74 }

View Code

 第二次代码：

#include 
#include 
#include <string.h>
int Map[10][10];
typedef struct
{
    int Dian;       /*记录当前这一点*/
    int Du;         /*记录当前这一点的度*/
}ID_S;
ID_S ID[15];
int CMP(const void*a,const void*b)
{       /*对结构体的Du进行降序排序*/
    return -(((ID_S*)a)->Du-((ID_S*)b)->Du);
}
int main()
{
    int T,i,j,N,sign;
    scanf("%d",&T);
    while(T--)
    {
        memset(Map,0,sizeof(Map));
        sign=1;
        scanf("%d",&N);
        for(i=0;i)
        {
            scanf("%d",&ID[i].Du);
            ID[i].Dian=i;
        }
        qsort(ID,N,sizeof(ID[0]),CMP);
        while(ID[0].Du>0&&sign)
        {   /*如果最大度为0或者sign=0（度存在为负时）时候跳出*/
            for(i=1;i<=ID[0].Du;i++)
            {
                Map[ID[0].Dian][ID[i].Dian]=1;
                Map[ID[i].Dian][ID[0].Dian]=1;
                ID[i].Du--;
                if(ID[i].Du<0){sign=0;break;}
            }
            ID[0].Du=0;
            qsort(ID,N,sizeof(ID[0]),CMP);
        }
        if(sign)
        {
            printf("YES\n");
            for(i=0;i)
            {
                for(j=0;j)
                {
                    printf("%d ",Map[i][j]);
                }
                putchar(10);
            }
        }
        else printf("NO\n");
        putchar(10);
    }
    return 0;
}

View Code

 

 

 

 

 

转载于:https://www.cnblogs.com/Wurq/articles/3888591.html