邻接表和邻接矩阵

进入图论的大门（深渊）之前，我们一定要掌握的两种必备手段——邻接表和邻接矩阵，此刻将成为我们的巨大帮手（其实做不来题还是做不来），下面让我们来学习一下，这两种存图方式在计算机中，该如何应用

1.邻接矩阵：就是一个二维数组，大小为dis[n][n]（n为顶点数），其中dis[i][j]表示顶点i到顶点j的距离，可以看出，邻接表的空间复杂度为O(n^2)，那怎么存边呢？如下：

for(int i = 0; i < m; i++)
{
    cin>>u>>v>>w;
    dis[u][v] = w;
    dis[v][u] = w;    //不是双向图可以把这句注释掉
}

以上表示在有m条边的图中，顶点u->v有一条权值为w的边，双向图加上v->u权值也为w

可以写一个邻接矩阵的初始化：

#define inf 0x3f3f3f3f
memset(dis,inf,sizeof dis);    //距离初始化为正无穷
for(int i = 1; i <= n; i++)    //边从1开始编号，1～n
    dis[i][i] = 0;            //自己到自己的距离为0

2.邻接表：邻接表是一部分人理解的难点，它的思想是，对每一个顶点，创建一个表，链接其所有出边，如下图： 

 假设存在这样的图：（u v w一组数表示顶点u到顶点v存在一条权值为w的边）

4 5        //4个顶点，5条边
1 4 9
4 3 8
1 2 5
2 4 6
1 3 7

于是我们可以画一个这样的图（图片来源：啊哈算法）：

 

这是个什么意思呢？这里我们用五个三个数组u[],v[],w[],first[],next[]来记录每一条边的信息，其实邻接表就是记录边的信息啊，所以我们来看看这些数组是什么意思：

首先我们对所有m条边进行编号，1～m，first[i]用来存顶点i的最后一条出边的编号，next[i]用来存编号为i的边的上一条边的编号，u[],v[]是顶点集合，w[]是边权集合，u[i],v[i],w[i]表示第i条边是从顶点v[i] -> 顶点u[i]，权值为w[i]的边，其实现在也说不明白，那我们就一步步模拟此过程：

根据输入的顺序，可以将边编号1~5：

4 5        //4个顶点，5条边
1 4 9        //1
4 3 8        //2
1 2 5        //3
2 4 6        //4
1 3 7        //5

 第一条边存入：u[1] = 1,v[1] = 4,w[1] = 9,next[1] = first[u[1]],(先保存上一条边编号)，first[u[1]] = 1;

第二条边存入：u[2] = 4,v[2] = 3,w[2] = 8,next[2] = first[u[2]],first[u[2]] = 2;

第三条边存入：u[3] = 1,v[3] = 2,w[3] = 5,next[3] = first[u[3]],first[u[3]] = 3;

第四条边存入：u[4] = 2,v[4] = 4,w[4] = 6,next[4] = first[u[4]],first[u[4]] = 4;

第五条边存入：u[5] = 1,v[5] = 3,w[5] = 7,next[5] = first[u[5]],first[u[5]] = 5;

 

最后解释一下，这么存的妙处在什么地方：

首先我们说了，first[i]表示顶点u[i]的最后一条出边的编号，注意是编号！那么，对于每一条输入的边，first[u[i]]就是以顶点u[i]为起点的边的编号，那么next[i] = first[u[i]]则表示，对于第i条边，next[i]保存的是以u[i]为起点的上一条边的编号，为何是上一条边？因为注意语句顺序，在next[i] = first[u[i]]执行完立即执行first[u[i]] = i，也就是将上一条输入的边的编号信息从first[]转移到next[]数组上了，first[]就可以存当前边的信息了，这样，我们通过first[]和next[]就可以遍历整个图了，过程如下图：

比如我们要找顶点1的所有出边，首先找到first[1]，然后根据next[first[1]]找到上一条边的编号，再通过next[next[first[1]]找到再上一条边的编号，一直继续搜索下去直到next[1] = -1为止，说明此时已遍历1号顶点所有出边（因为在没插入边的时候，head[1] = -1,而-1的值赋给了next[1]，找到-1说明不存在上一条边了）

是不是很神奇！但是我们这里为了组织边的时候看起来更具有整体性，不用五个数组存边，我们用一个结构体+head[]的形式，其中head[]就是上文的first[]，代码如下：

#define maxn 5250    //最大边数
#define vertex 505   //最大点数

struct node
{
    int to,v,next;
}e[maxn];

int head[vertex+1],cnt;

void init()            //初始化操作
{
    cnt = 0;
    memset(head,-1,sizeof head);
}

void addedge(int u,int v,int w)    //加边操作
{
    e[cnt].to = v;
    e[cnt].v = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}

for(int i = 1; i <= vertex; i++)    //遍历所有顶点的所有出边;
{
    for(int j = head[i]; j != -1; j = e[j].next)    //从head[i],通过不断找next[j]，来遍历顶点i的所有出边;
    {
        cout<<i<<" "<<e[j].to<<" "<<e[j].v<<endl;
    }
}

看起来很高大上？其实并没有，只是将v[]换成结构体的to成员，w[]换成结构体的v成员，next[]换成结构体的next成员，（结构体数组相当于成员数组的集合嘛），first[]换成head[]而已， 那么有人就要问了，为什么不用u[]呢？因为这样存边在大多情况下，不需要用到u[]，具体原因可以具体考虑，当然加上u成员也无妨只是多一点空间开销嘛，比如在Bellman-Ford算法中u成员将会带来很大的便利，还是要看使用情况而定的

 

当然，还有更直接，更接近于链表形式的邻接表表示法，那就是利用STL中的vector存一个图，这样的邻接表更易理解和使用，但是传说中有些题目可能卡vector而必须用数组模拟的方式写过，目前我还没有遇见这样的题目，但是这里还是介绍一下vector存图的方法（并且建议使用该方法）：

首先明确，vector实质上是一个动态数组的玩意儿，就是不定长数组，根据需要分配空间的意思，关于vector的使用方法，由于篇幅有限，只介绍几个常用的：

#include<vector>
using namespace std;

vector<int> a;

a[0];                //直接按下标访问元素（不会检查是否越界）
a.push_back(3);    //将元素3插入数组最后
a.pop_back();     //删除数组中最后一个元素
a.insert(a.begin(),5);        //两个参数，插入位置，插入元素值
a.erase(a.end());          //一个参数，要删除的位置
a.empty();        //判断数组是否为空
a.clear();        //清空数组
a.size();        //返回数组此刻长度
a.begin();        //迭代器指针
a.end();           //迭代器尾指针
a.cbegin();        //常量头指针
a.cend();            //常量尾指针

根据邻接表和vector的特性，我只需要将顶点i的出边，都存在一个数组里vector[i]，就好了！那么数组vector是什么类型的呢？应该是“边”这种类型，我们可以设一个结构体类型，如下：

#define maxn 5250    //最大点数;

struct node
{
    int to,v;    //to代表到哪个顶点，v代表权值
};

vector<node> e[maxn];    //每个点都有自己的邻接表，vector是一个node类型的数组

那么怎么插入边呢？

void addedge(int u,int v,int w)    //u->v = w;
{
    node tmp;
    tmp.to = v;
    tmp.v = w;
    e[u].push_back(tmp);    //关于顶点u的邻接表
}

是不是特别好理解？这样邻接表就建好了，那要怎么遍历一个顶点边的信息呢？

for(int i = 0; i < e[1].size(); i++)    //遍历1号顶点所有出边
{
    cout<<1<<e[1][i].to<<e[1][i].v<<endl;
}
//输出应该会是（根据上图）：
1 4 9
1 2 5
1 3 7

将完整的模块拼在一起就是：

#define n 5250    //最大点数;
#include<vector>
using namespace std;

struct node
{
    int to,v;    //to代表到哪个顶点，v代表权值
};

vector<node> e[n+1];    //每个点都有自己的邻接表，vector是一个node类型的数组

void init()
{
    for(int i = 0; i <= n; i++)
        e[i].clear();
}

void addedge(int u,int v,int w)    //u->v = w,加边
{
    node tmp;
    tmp.to = v;
    tmp.v = w;
    e[u].push_back(tmp);    //关于顶点u的邻接表
}


for(int i = 1; i <= n; i++)
{
    for(int j = 0; j < e[i].size(); j++)    //遍历i号顶点所有出边
    {
        cout<<i<<e[i][j].to<<e[i][j].v<<endl;    //顶点i的第j条出边
    }
}

//根据上图，输出应该是：
1 4 9
1 2 5
1 3 7
2 4 6
4 3 8

当然，只有两个成员的结构体，我们可以考虑用pair代替（万能的STL啊！），注意make_pair(a,b);的快捷操作：

#define n 5250    //最大点数;
#include<vector>
using namespace std;
typedef pair<int,int> pir;    //pir.first代表到哪个顶点，pir.second代表权值

vector<pir> e[n+1];    //每个点都有自己的邻接表，vector是一个pair类型的数组

void init()
{
    for(int i = 0; i <= n; i++)
        e[i].clear();
}

void addedge(int u,int v,int w)    //u->v = w,加边
{
    e[u].push_back(make_pair(v,w));    //关于顶点u的邻接表
}


for(int i = 1; i <= n; i++)
{
    for(int j = 0; j < e[i].size(); j++)    //遍历i号顶点所有出边
    {
        cout<<i<<e[i][j].to<<e[i][j].v<<endl;    //顶点i的第j条出边
    }
}

//根据上图，输出应该是：
1 4 9
1 2 5
1 3 7
2 4 6
4 3 8

对了，也许有人要问，为什么是e[i][j]呢？显然e[n]是一个二维数组啊，因为每一个点的出边本身是一个数组啊，不止有一条出边，所以相当于往动态数组里存数组，当然是二维数组了，可以访问e[i][j]，表示，顶点i的第j条出边，关于pair，本身没什么好讲的，很简单就不介绍了.

今天关于存图的方法，就写到这里，相信该是够用了吧