ZOJ 3732 Graph Reconstruction （Havel-Hakimi定理）

题意：给出一张无向图中每个点的度，问是否存在对应的无向简单图。如果存在，是否存在多解，并输出对应的图。
思路：给出图中每点的度，判定对应的图是否存在，叫做可图判定性问题。
对于无向图，我们有
Havel—Hakimi定理：
由非负数组成的非增序列s:d1，d2，···，dn（n>=2，d1>=1）是可图的，当仅当序列 s1：d2-1，d3-1，···，dd1+1 -1,dd1+2，····，dn是可图的。
这个定理是递归的，我们就可以用算法来直接判定。
而无法构成图的条件是：1.最大度的点超过了其他的需要连边的点的总数量，即，该点即使向其他所有的能连边的点都连边，也不能满足其度，不可能。
                                    2一个点的度减到负。即，剩下能够连边的点的数量不够度最大点的度，不可能。

如果sort(p+i, p+n)排序后，从i分别向i+1, i+2...i+p[i].d连边时，如果i+p[i].d跟i+p[i].d+1的剩余度数相同，那么交换这两个点在剩下的图中的位置，就能得到两个不同的图了。.

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn = 1e2 + 7;
const int maxm = maxn*maxn;
int n, tot;
pair<int, int> e1[maxm], e2[maxm]; //存两种图的边
struct node
{
    int d, id;
    bool operator < (const node &a) const
    {
        return d > a.d;
    }
}p[2][maxn];
bool solve(node *p, pair<int, int> *e)
{
    int cnt = 0;
    for(int i = 0; i < n-1; i++)
    {
        sort(p+i, p+n);
        if(p[i].d+i > n-1) return 0; //如果度数大于所有点的个数
        for(int j = i+1; j <= p[i].d+i; j++)
        {
            if(--p[j].d < 0) return false;
            e[cnt++] = make_pair(p[i].id+1, p[j].id+1);
        }
//        cout << cnt << "*****" << endl;
    }
    return p[n-1].d == 0;
}
bool check(node *p, pair<int, int> *e)
{
    int cnt = 0, res = 0;
    for(int i = 0; i < n-1; i++)
    {
        sort(p+i, p+n);
        int tmp = p[i].d + i;
        if(tmp < n-1 && p[tmp].d == p[tmp+1].d && p[tmp].d != 0)
        {
            res = 1;
            swap(p[tmp].id, p[tmp+1].id);
        }
        for(int j = i+1; j <= tmp; j++)
            p[j].d--, e[cnt++] = make_pair(p[i].id+1, p[j].id+1);
    }
    return res;
}
void print(pair<int, int> *e)
{
    printf("%d %d\n", n, tot);
    for(int i = 0; i < tot; i++) printf("%d%c", e[i].first, i == tot-1 ? '\n' : ' ');
    for(int i = 0; i < tot; i++) printf("%d%c", e[i].second, i == tot-1 ? '\n' : ' ');
    if(tot == 0) printf("\n\n");
}
int main()
{
    while(~scanf("%d", &n))
    {
        tot = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &p[0][i].d);
            p[0][i].id = i;
            p[1][i] = p[0][i];
            tot += p[0][i].d;
        }
        if(tot&1) puts("IMPOSSIBLE"); //一条边肯定增加2个度
        else
        {
            tot /= 2;
            if(!solve(p[0], e1)) puts("IMPOSSIBLE");
            else
            {
                if(check(p[1], e2))
                {
                    puts("MULTIPLE");
                    print(e1);
                    print(e2);
                }
                else
                {
                    puts("UNIQUE");
                    print(e1);
                }
            }
        }
    }
    return 0;
}