可图性判定—Havel-Hakimi定理(POJ 1659)

 

 Havel—Hakimi定理：由非负数组成的非增序列s:d₁，d₂，···，d_n（n>=2，d1>=1）是可图的，当仅当序列

                  s₁：d₂-1，d₃-1，···，d_d1+1 -1,d_d1+2，····，d_n

是可图的。序列s1中有n-1个非负数，s序列中d1后的前d1个度数减1后构成s1中的前d1个数。

 判定过程：（1）对当前数列排序，使其呈递减

                  （2）从S【2】开始对其后S【1】个数字-1

                  （3）一直循环直到当前序列出现负数（即不是可图的情况）或者当前序列全为0 （可图）时退出。

例题：POJ 1659 Frogs' Neighborhood

 

代码： 

 1 #include <algorithm>
 2 #include <iostream>
 3 #include <cstring>
 4 #include <cstdio>
 5 using namespace std;
 6 const int N=16;
 7 struct node
 8 {
 9     int degree;//顶点的度数
     int index;//顶点的序号
 }p[N];
 int cmp(const void *a,const void *b)
 {
     return ((struct node *)b)->degree-((struct node *)a)->degree;
 }
 int main()
 {
     int t,n,i,j,k,flag;
     int map[N][N];
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         for(i=0;i<n;i++)
         {
             scanf("%d",&p[i].degree);
             p[i].index=i;
         }
         memset(map,0,sizeof(map));
         flag=1;
         for(j=0;j<n&&flag;j++)
         {
             qsort(p+j,n-j,sizeof(p[0]),cmp);//对p数组后n-j个元素排序
             i=p[j].index;
             int d=p[j].degree;
             if(d>n-j-1)
                 flag=0;
             for(k=1;k<=d&&flag;k++)
             {
                 int jj=p[j+k].index;
                 if(p[j+k].degree<=0)
                     flag=0;
                 p[j+k].degree--;
                 map[i][jj]=map[jj][i]=1;
             }
         }
         if(flag)
         {
             puts("YES");
             for(i=0;i<n;i++)
             {
                 for(j=0;j<n;j++)
                 {
                     if(j)
                         printf(" ");
                     printf("%d",map[i][j]);
                 }
                 puts("");
             }
         }
         else
             puts("NO");
         if(t)
             puts("");
     }
 }