poj1659 - Frogs' Neighborhood （利用Havel-Hakimi定理判断一个序列是否是可图的）

Frogs' Neighborhood

Time Limit: 5000MS		Memory Limit: 10000K
Total Submissions: 7592		Accepted: 3258		Special Judge

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 

Source

POJ Monthly--2004.05.15 Alcyone@pku

 

 

qsort函数资料： http://blog.sina.com.cn/s/blog_5155e8d401009145.html

            科普了下qsort函数，排序的确方便许多。 

 

/*********************************
*
*   acm:   poj-1659
*
*   title: Frogs' Neighborhood
*
*   time : 2014.11.15-16
*
*********************************/

//考察 Havel-Hakimi定理

/*
    Havel-Hakimi定理:
        定理实际上给出了根据一个序列s构造图（或判定s不是可图的）方法：
    把序列s按照非增顺序排序后，其顺序为d1，d2，...，dn；度数最大的顶点设为v1，将它
    与度数次大的前d1个顶点之间连边，然后这个顶点就可以不管了，即在序列中删除首项d1，
    并把后面的d1个度数减1；再把剩下的序列重新按非增顺序排序，按照上述过程连边；.....
    直到建出完整的图，或不合理情况为止。

    有两种不合理情况：
       （1）某次对剩下序列排序后，最大的度数（设为d1）超过了剩下的顶点数。
       （2）对最大度数后面的d1个度数各减1后，出现负数。
*/

/*
    分析：本题实际上是给定一个非负整数序列，问是不是一个可图的序列，也就是说
能不能根据这个序列造一个图。
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int VertexType;
typedef int EdgeType;

#define MAXVEX 10

#define TRUE 1
#define FALSE 0

typedef struct Vertex
{
    int degree;  //顶点的度
    int index;   //顶点的序号
} Vertex;

typedef struct MGraph
{
    Vertex vexs[MAXVEX];
    EdgeType arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
} MGraph;

int cmp(const void *a, const void *b)
{
    Vertex *aa = (Vertex *)a;
    Vertex *bb = (Vertex *)b;

    return bb->degree - aa->degree;
}

int main()
{
    int T;
    MGraph G;
    int i, j;
    int degree;
    int flag;    //序列是否可图的标志

    int d1;   //对剩下序列排序后第一个顶点（度数最大的顶点）的度数
    int k;    //最大顶点序号
    int r;  //d1后面的每个顶点的序号

    scanf("%d", &T);

    while (T--)
    {
        scanf("%d", &G.numVertexes);

        memset(G.arc, 0, sizeof(G.arc));

        for (i = 0; i < G.numVertexes; i++)
        {
            scanf("%d", &degree);

            G.vexs[i].index = i;
            G.vexs[i].degree = degree;
        }

        flag = TRUE;

        for (i = 0; i < G.numVertexes && flag; i++)
        {
			//快排函数 参数依次介绍：地址；  参与排序元素的个数；  单元空间大小使用sizeof(s[0])；比较函数；
            qsort(G.vexs + i, G.numVertexes - i, sizeof(G.vexs[0]), cmp); 

            k = G.vexs[i].index;       //第i个顶点的序号
            d1 = G.vexs[i].degree;

            if (d1 > G.numVertexes - i - 1)  //最大的度数超过了剩下的顶点数。
            {
                flag = FALSE;
            }

            for (j = 1; j <= d1 && flag; j++)
            {
                r = G.vexs[i+j].index;

                if (G.vexs[i + j].degree <= 0)  //如果对d1个度数各减去1后出现负数
                {
                    flag = FALSE;
                }

                G.vexs[i+j].degree--;

                G.arc[k][r] = G.arc[r][k] = TRUE;  //表示有渠道
            }
        }

        if (flag)
        {
            printf("YES\n");
            for (i = 0; i < G.numVertexes; i++)
            {
                printf("%d", G.arc[i][0]);
                for (j = 1; j < G.numVertexes; j++)
                {
                    printf(" %d", G.arc[i][j]);
                }

                printf("\n");
            }
        }
        else
        {
            printf("NO\n");
        }

        if (T)
        {
            printf("\n");
        }
    }

    return 0;
}