图的常见储存方式

1：邻接矩阵

cost[i][j] = inf说明i没有到j的边

cost[i][j] != inf说明i到j的费用是cost[i][j]

方便，但是空间占用大，稀疏图会很浪费，遍历也很耗时，

空间O（n * n）

2：前向星

struct Edge
{
    int from;
    int to;
    int cost;
};

用结构体储存每条边的起点终点和费用，和1差不多

3：领接表：

（1）结构实现：

结构：

struct Edge
{
    int to;
    int w;
    Edge * next;
};

struct  Vnode
{
     int from;
     Edge * first;
}node[maxn];

读入方式：

        Edge *p = new Edge();
        int u, v, cost;
        cin >> u >> v >> cost;
        p -> to = v;
        p -> w = cost;
        p -> next = node[u].first;
        node[u].first = p;

第一个结构体是存每条边的信息

第二个结构体是存每个起点的信息，node[i].first是节点i连的第一条边的指针，这个指针所指的边e的next是节点i所连接的下一条边

在读入过程中可以发现起点一样为i的边都存在了node[i]的first形成的链表里，但是顺序反着来的

例如：1 5 3，... ，1 7 8，

 首先1->5这条边存下了终点5和权值3，然后使p ->next指向了node[1].first（NULL），然后再把first指回p，这样你就可以访问通过first直接访问边1 ->5

这时该边的next指向NULL，再然后又遇到起点为1的1 -> 7这条边，重复上面的步骤，p1（1 -> 7）->next 指向node[1].first（1 -> 5），然后first再指向p1，

这时你访问node[1].first得到p1（1 -> 7），然后从p1 -> next得到p（1 -> 5），再然后p -> next为NULL。

形象化解释原理：

对于每个起点，这里有一个栈，里面有个first，值为NULL，然后你放进去一条边放在first上面（p ->next=node[1].first），有强迫症的你觉得first不能在下面，

于是为了世界和平你决定把最上面的P改名为first，这时first就是p，（那之前的first所在的位置怎么办呢：我们就抛弃他了），于是现在栈里面是first（p）

下面是一个NULL（之前的first），现在又来了一条边放进去，又放到了first上面（p1 ->next=node[1].first ），=-=，于是无奈的你又把p1改成了first，这时栈

里面有first（p1） -> p -> NULL

样例：

8 12
5 8 29
6 1 12
8 3 11
1 2 4
3 1 22
4 3 17
7 4 25
6 5 9
8 7 7
1 6 9
3 2 19
6 7 4

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#define maxn 100

using namespace std;

int n, m;

struct Edge
{
    int to;
    int w;
    Edge * next;
};

struct  Vnode
{
     int from;
     Edge * first;
}node[maxn];

int main()
{
    cin >> n >> m;
    for(int i = 0; i < m; i++)
    {
        Edge *p = new Edge();//动态建图挺好的，但是后面没有释放内存，直接初始化maxm个Edge也是可以的
        int u, v, cost;
        cin >> u >> v >> cost;
        p -> to = v;
        p -> w = cost;
        p -> next = node[u].first;
        node[u].first = p;
    }
    printf("\n\n\n");
    for(int i = 1; i <= n; i++)
    {
        for(Edge * k = node[i].first; k != NULL; k = k -> next)
        {
            printf("%d %d %d\n", i, k -> to, k -> w);
        }
    }
    return 0;
}

（2）vector实现（不用自己申请内存和释放，不易犯错）

对于无权图（比如涂色问题）：

vector<vector<int>> Map或者vector<int> Map[maxn]；（个人习惯前一种）

样例：

8 12
5 8
6 1
8 3
1 2
3 1
4 3
7 4
6 5
8 7
1 6
3 2
6 7

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#define maxn 100

using namespace std;

int n, m;

vector<vector<int>> A(maxn);

int main()
{
    cin >> n >> m;

    for(int i = 0; i < m; i++)
    {
        int u, v;
        cin >> u >> v;
        A[u].push_back(v);
        //如果是无向图的话加上A[v].push_back(u);
    }
    for(int i = 1; i <= n; i++)
    {
        for(auto x : A[i])//c++11支持
        {
            cout << i << "->" << x << endl;
        }
    }
    return 0;
}

结果：

带权图：

把存点改成存边就好了

struct Edge
{
    int to;
    int cost;
};

用vector<vector<Edge>> Map或者vector<Edge> Map[maxn]；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#define maxn 100

using namespace std;

int n, m;

struct Edge
{
    int to;
    int cost;
    Edge(int x, int y)
    {
        to = x;
        cost = y;
    }
};
vector<vector<Edge>> A(maxn);

int main()
{
    cin >> n >> m;

    for(int i = 0; i < m; i++)
    {
        int u, v, c;
        cin >> u >> v >> c;
        Edge tmp(v, c);
        A[u].push_back(tmp);
    }
    for(int i = 1; i <= n; i++)
    {
        for(auto x: A[i])
        {
            cout << i << "->" << x.to << " " << x.cost << endl;
        }
    }
    return 0;
}

4:链式前向星（相对上面的来说比较优）：

用head数组做辅助作用，head[i]表示节点i为起点的边的链表的头，其他的和领接表差不多

int head[maxn] //初始化-1

struct P

{

    int to;

    int cost;

    int next;

};

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#define maxn 100
#define maxm 1000

using namespace std;

int n, m;
int head[maxn]; //初始化-1

struct P
{
    int to;
    int cost;
    int next;
}Edge[maxm];

int main()
{
    cin >> n >> m;
    memset(head, -1, sizeof(head));

    for(int i = 0; i < m; i++)
    {
        int u, v, c;
        cin >> u >> v >> c;
        Edge[i].to = v;
        Edge[i].cost = c;
        Edge[i].next = head[u];
        head[u] = i;
    }

    for(int i = 1; i <= n; i++)
    {
        for(int j = head[i]; j != -1; j = Edge[j].next)
        {
            cout << i << "->" << Edge[j].to << " " << Edge[j].cost << endl;
        }
    }
    return 0;
}