图的存储表示——邻接矩阵

例题一：用邻接矩阵存储一个有向图，并输出图的出度和入度

输入：

7 9

1 2

2 3

2 5

2 6

3 5

4 3

5 2

5 4

6 7

0 0

输出：

1 3 1 1 2 1 0

0 2 2 1 2 1 1

#include<cstdio>
#include<iostream>
#include<cstring>
#define MAXN 100
using namespace std;
int Edge[MAXN][MAXN];
int main()
{
    int i,j;
    int n,m;
    int u,v;
    int od,id;
    while(1)
    {
        scanf("%d%d",&n,&m);
        if(n==0&&m==0)
            break;
        memset(Edge,0,sizeof(Edge));
        for(i=1;i<=m;i++)/// 存储图
        {
            scanf("%d%d",&u,&v);
            Edge[u-1][v-1]=1;
        }
        for(i=0;i<n;i++)///计算各点的出度
        {
            od=0;
            for(j=0;j<n;j++)
                od+=Edge[i][j];
            if(i==0)
                printf("%d",od);
            else
                printf(" %d",od);
        }
        printf("\n");
        for(i=0;i<n;i++)///计算各点的入度
        {
            id=0;
            for(j=0;j<n;j++)
                id+=Edge[j][i];
            if(i==0)
                printf("%d",id);
            else
                printf(" %d",id);
        }
        printf("\n");
    }
    return 0;
}

Havel-Hakimi定理：

由非负整数组成的非增序列 S;d1,d2,d3.......dn(n>=2,  d1>=1)是可图的，当且仅当序列S1：d2-1,d3-1,.....d(d1+1)-1,  d(d1+2) ,  dn是可图的。

Frogs' Neighborhood(poj 1659)

未名湖附近共有 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。每两个数字之间输出一个空格。如果存在多种可能，只需给出一种符合条件的情形。相邻两组测试数据之间输出一个空行。  

   分析：本题的意思实际上是给定一个非负整数序列，问是不是一个可图的序列，也就是说能不能根据这个序列构造出一个图。这就需要根据Havel-Hakimi定理的方法来构造图，并在构图过程中判断是否出现了不合理的情形。

(1) 某次对剩下的序列排序后，最大的度数d1超过了剩下的顶点数。

(2)对最大度数后面的d1个度数各减一后，出现了负数。

一旦出现以上两种情形中的一种，即可判定该图是不可图的

如果一个序列是可图的，本题还要求输出构造得到的图的邻接矩阵，实现思路如下：

(1)为确保顶点序号与输入时的度数一致，特意声明了一个vertex结构体，包含了顶点的度和序号两个成员

(2)每次对剩下的顶点按度数从大到小排序后，设最前面的顶点(即当前度数最大的顶点)的序号为 i，度数为 d1，对后面d1个顶点的每个顶点(序号设为j)的度数减一，并连边，即在邻接矩阵Edge中设置Edge[i][j]和Edge[j][i]为1.

#include<cstdio>
#include<iostream>
#include<cstring>
#include<stdlib.h>
#define N 15
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 i,j,k,r;
    int t,n;///测试数据的个数，湖泊个数
    int d1;///对剩下序列排序后第一个顶点(度数最大的点)的度数
    int Edge[N][N],flag;
    cin>>t;
    while(t--)
    {
        scanf("%d",&n);
        for(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;
                break;
            }
            for(r=1;r<=d1&&flag;r++)
            {
                j=v[k+r].index;
                if(v[k+r].degree<=0)///先判断一下是否满足构图条件
                {
                    flag=0;
                    break;
                }
                v[k+r].degree--;
                Edge[i][j]=Edge[j][i]=1;
            }
        }
        if(flag)
        {
            ///puts("YES");///字符串后面以\0结尾，自动换行
            printf("YES\n");
            for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                {
                    if(j==0)
                        printf("%d",Edge[i][j]);
                    else
                        printf(" %d",Edge[i][j]);
                }
                printf("\n");
            }
        }
        else
            printf("NO\n");
        if(t)
            printf("\n");
    }
    return 0;
}