进入图论的大门（深渊）之前，我们一定要掌握的两种必备手段——邻接表和邻接矩阵，此刻将成为我们的巨大帮手（其实做不来题还是做不来），下面让我们来学习一下，这两种存图方式在计算机中，该如何应用
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; //自己到自己的距离为02.邻接表：邻接表是一部分人理解的难点，它的思想是，对每一个顶点，创建一个表，链接其所有出边，如下图：
假设存在这样的图：（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[i].to<<" "<<e[i].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 = i; j < e[j].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 = i; j < e[j].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，本身没什么好讲的，很简单就不介绍了（连头文件都不用）
今天关于存图的方法，就写到这里，相信该是够用了吧