POJ-1659-Frogs' Neighborhood （Havel-Hakimi定理）

利用Havel-Hakimi定理可判定一个序列是否可图。

Havel-Hakimi定理：

由非负整数组成的非增序列s:d1,d2。。。dn(n>=2 , d1 >= 1)是可图的，当且仅当序列

s1:d2-1,d3-1,d4-1...d(d1+1)-1...dn

是可图的。序列s1中有n-1个非负整数，s序列中d1后的前d1个度数（即d2--d(d1+1)）减一后构成s1中的前d1个数。

例如：

判断序列s：7 7 4 3 3 3 2 1是否是可图的。

删除序列s的首项7，对其后的7项每一项都减1，得到：6 3 2 2 2 1 0；

继续删除首项6，对其后的6项，每一项都减1，得到：2 1 1 1 0  -1，得到这一步出现了负数。

由于图中不可能存在负度数的顶点，因此该序列不是可图的。

再举一个例子：

判断序列s：5 4 3 3 2 2 2 1 1 1 是否是可图的。

删除序列的首项5，对其后的5项每一项的度数都减1，得到：3 2 2 1 1 2 1 1 1，

重新降序排列为：3 2 2 2 1 1 1 1 1 ；

再删除首项3，对其后的3项，每一项的度数减1，得到：1 1 1 1 1 1 1 1 ；

如此再陆续的得到序列：1 1 1 1 1 1 0；1 1 1 1 0 0；1 1 0 0 0；0 0 0 0.

由此也判定该序列是可图的。

Havel-Hakimi定理实际上给出了根据一个序列s构造图（或判断该序列是否可图）的方法：

把序列s按照降序排序以后，度数最大的顶点设为v1，将它与度数次大的前v1个顶点之间连边，然后这个顶点就可以不管了，因为它的度数已经用完了（连接了v1条边），即在原序列中删除v1，并把其后的v1个顶点的度数减1；

再把剩下的序列重新降序排列，按照上边的过程连边，度数减1.。。。直到建出完整的图，或出现负度数等明显不合理的情况为止。

题目：POJ1659青蛙的邻居

这个题目就是根据Havel-Hakimi定理来构图，看是否可图，并还原邻接矩阵。

有以下两种不合理的情形：

1.某次对剩下的序列排序后，最大的度数（设为d）超过了剩下的定点数。

2.对最大的度数后面d个度数各减1后，出现了负数。

一旦出现了上述两种情形之一即可判定该序列式不可图的。

代码如下：

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

struct node
{
    int degree;
    int v;
} p[100];

int mapp[100][100];

int cmp (const void *a,const void *b)
{
    return (*(struct node*)b).degree - (*(struct node *)a).degree;
}

int main()
{
    int t,n,d,x,y,flag;
    cin>>t;
    while (t--)
    {
        cin>>n;
        memset(mapp,0,sizeof (mapp));
        for (int i = 0; i < n; i++)
        {
            cin>>p[i].degree;
            p[i].v = i;
        }
        flag = 1;
        for (int k = 0; k < n; k++) if (flag )
            {
                qsort (p + k,n - k,sizeof (p[0]),cmp);
                d = p[k].degree;
                x = p[k].v;
                if (d >= n - k )
                    flag = 0;
                for (int j = 1; j <= d; j++) if (flag)
                    {
                        y = p[k + j].v;
                        if (p[k + j].degree <= 0)
                            flag = 0;
                        p[k + j].degree--;

                        mapp[x][y] = mapp[y][x] = 1;
                    }
            }
        if (flag )
        {
            cout<<"YES"<<endl;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    cout<<mapp[i][j];
                    if (j < n - 1)
                        cout<<" ";
                }
                cout<<endl;
            }

        }
        else
            cout<<"NO"<<endl;
        if (t)
            cout<<endl;
    }

    return 0;
}