poj1659-Havel-Hakimi定理

Havel-Hakimi定理:
有非负整数组成的非增序列s（代表顶点的度数）:d1,d2······dn(n>=2,d1>=1,di>=0)是可图的。
例如：
s:7,6,5,5,2,1,2,1
判断s是否可图，只需先将s排序，得s:7,6,5,5,2,2,1,1.第一项为7，所以7后面的7项全部减一，7舍去，排序后得s:5,4,4,1,1,0,0.第一项为5，第一项去掉，后五项减一，排序后s:3,3,0,0,0,-1.s中出现了负数，所以不可图。
下面出题：
Frogs’ Neighborhood
Time Limit: 5000MS Memory Limit: 10000K
Total Submissions: 10422 Accepted: 4327 Special Judge
Description

未名湖附近共有N个大小湖泊L1, L2, …, Ln(其中包括未名湖)，每个湖泊Li里住着一只青蛙Fi(1 ≤ i ≤ N)。如果湖泊Li和Lj之间有水路相连，则青蛙Fi和Fj互称为邻居。现在已知每只青蛙的邻居数目x1, x2, …, xn，请你给出每两个湖泊之间的相连关系。

Input

第一行是测试数据的组数T(0 ≤ T ≤ 20)。每组数据包括两行，第一行是整数N(2 < N < 10)，第二行是N个整数，x1, x2,…, xn(0 ≤ xi ≤ 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

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
[Submit] [Go Back] [Status] [Discuss]。
解题思路：
这就是从度数最高的顶点往下，依次用Havel-Hakimi判断。
上代码：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=50;
int G[maxn][maxn];
struct jd{
    int ds,id;
}v[maxn];
int cmp(struct jd a,struct jd b)
{
    return a.ds>b.ds;
}
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d",&v[i].ds);
            v[i].id=i;
        }
        int f=1;
        memset(G,0,sizeof(G));
        for(int i=0;i<n&&f;i++)//对于每一个顶点进行Havel-Hakimi定理判定
        {
            sort(v+i,v+n,cmp);
            int d=v[i].id;
            int k=v[i].ds;
            if(k>n-i-1){f=0;break;}
            for(int j=1;j<=k&&f;j++)
            {
                int h=v[i+j].id;
                if(v[i+j].ds<=0){f=0;break;}
                v[i+j].ds--;
                G[d][h]=G[h][d]=1;
            }
        }
        if(f){
            printf("YES\n");
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(j==n-1)
                        printf("%d\n",G[i][j]);
                    else
                        printf("%d ",G[i][j]);
                }
            }
        }
        else
            printf("NO\n");
        if(t)
            printf("\n");
    }
    return 0;
}

之前按照模板打得用的stdlib.h中qsort排序，发现时间耗费比sort少很多，下面是qsort的代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 50
using namespace std;

struct vertex{
    int degree;//度数
    int index;//序号
}v[N];
int cmp(const void *a,const void *b)
{
    return ((vertex*)b)->degree-((vertex*)a)->degree;
}
int main()
{
    int r,k,p,q;
    int i,j;
    int d1;
    int T,n;
    int Edge[N][N],flag;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%d",&v[i].degree);
            v[i].index=i;
        }
        memset(Edge,0,sizeof(Edge));
        flag=1;
        for(k=0;k<n&&flag;k++)
        {
            qsort(v+k,n-k,sizeof(vertex),cmp);
            i=v[k].index;
            d1=v[k].degree;
            if(d1>n-k-1)flag=0;
            for(r=1;r<=d1&&flag;r++)
            {
                j=v[k+r].index;
                if(v[k+r].degree<=0)flag=0;
                v[k+r].degree--;
                Edge[i][j]=Edge[j][i]=1;
            }
        }
        if(flag)
        {
            puts("YES");
            for(int x=0;x<n;x++)
            {
                for(int y=0;y<n;y++)
                {
                    if(y)
                        printf(" ");
                    printf("%d",Edge[x][y]);
                }
                printf("\n");
            }
        }
        else
            printf("NO\n");
        if(T)
            printf("\n");
    }
    return 0;
}

poj1659-Havel-Hakimi定理

猜你喜欢