链式前向星---结点之间建立边
如果说邻接表是不好写但效率好，邻接矩阵是好写但效率低的话，前向星就是一个相对中庸的数据结构。前向星固然好写，但效率并不高。而在优化为链式前向星后，效率也得到了较大的提升。虽然说，世界上对链式前向星的使用并不是很广泛，但在不愿意写复杂的邻接表的情况下，链式前向星也是一个很优秀的数据结构。
——摘自《百度百科》
链式前向星：静态邻接表
邻接表，存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。
对于无向图来说，使用邻接表进行存储也会出现数据冗余，表头结点A所指链表中存在一个指向C的表结点的同时，表头结点C所指链表也会存在一个指向A的表结点。
时间效率：O（m）
空间效率：O（m）
遍历效率：O（m）
例：
第一行为五个顶点，七条边，第二行开始依次为起点，终点，权值
5 7
1 2 1
2 3 2
3 4 3
1 3 4
4 1 5
1 5 6
4 5 7
具体代码：
点击查看代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;//点数最大值
int n, m, cnt;//n个点，m条边
struct Edge
{
int to, w, next;//终点，边权，同起点的上一条边的编号
}edge[maxn];//边集
int head[maxn];//head[i],表示以i为起点的第一条边在边集数组的位置（编号）
void init()//初始化
{
for (int i = 0; i <= n; i++) head[i] = -1;
cnt = 0;
}
void add_edge(int u, int v, int w)//加边，u起点，v终点，w边权
{
edge[cnt].to = v; //终点
edge[cnt].w = w; //权值
edge[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
head[u] = cnt++;//更新以u为起点上一条边的编号
}
int main()
{
cin >> n >> m;
int u, v, w;
init();//初始化
for (int i = 1; i <= m; i++)//输入m条边
{
cin >> u >> v >> w;
add_edge(u, v, w);//加边
/*
加双向边
add_edge(u, v, w);
add_edge(v, u, w);
*/
}
for (int i = 1; i <= n; i++)//n个起点
{
cout << i << endl;
for (int j = head[i]; j != -1; j = edge[j].next)//遍历以i为起点的边
{
cout << i << " " << edge[j].to << " " << edge[j].w << endl;
}
cout << endl;
}
return 0;
}
其中变量定义为
_head[i]数组:表示以 i 为起点的最后一条边的编号。
_Next:表示与这个边起点相同的上一条边的编号。
其中加边函数为：
点击查看代码
void add_edge(int u, int v, int w)//加边，u起点，v终点，w边权
{
edge[cnt].to = v; //终点
edge[cnt].w = w; //权值
edge[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
head[u] = cnt++;//更新以u为起点上一条边的编号
}
其中遍历函数为：
点击查看代码
for(int i = 1; i <= n; i++)//n个起点
{
cout << i << endl;
for(int j = head[i]; j != -1; j = edge[j].next)//遍历以i为起点的边
{
cout << i << " " << edge[j].to << " " << edge[j].w << endl;
}
cout << endl;
}
第一层for循环是找每一个点，依次遍历以【1，n】为起点的边的集合。第二层for循环是遍历以 i 为起点的所有边，k首先等于head[ i ]，注意head[ i ]中存的是以 i 为起点的最后一条边的编号。然后通过edge[ j ].next来找下一条边的编号。我们初始化head为-1，所以找到你最后一个边（也就是以 i 为起点的第一条边）时，你的edge[ j ].next为 -1做为终止条件。
代码实现过程：
对于1 2 1这条边：edge[0].to = 2; edge[0].next = -1; head[1] = 0;
对于2 3 2这条边：edge[1].to = 3; edge[1].next = -1; head[2] = 1;
对于3 4 3这条边：edge[2].to = 4; edge[2],next = -1; head[3] = 2;
对于1 3 4这条边：edge[3].to = 3; edge[3].next = 0; head[1] = 3;
对于4 1 5这条边：edge[4].to = 1; edge[4].next = -1; head[4] = 4;
对于1 5 6这条边：edge[5].to = 5; edge[5].next = 3; head[1] = 5;
对于4 5 7这条边：edge[6].to = 5; edge[6].next = 4; head[4] = 6;
具体实例：
★实验任务
有一块很大的农场！农场里分成了 n 块农田,编号为 1-n，这些农田由 n-1 个沟渠联通 着。 这些沟渠中的一些已经干涸了，农场主想要让所有沟渠都保持有水。但是他只能在农田 里浇水。如果他在某块农田里浇了水，那么从这块农田到 1 号农田简单路径上的沟渠都会处 于有水的状态。显然，这样的路径只会有一条。 这个农场主想知道，他最少要浇几块农田，才能让所有沟渠都有水。
★数据输入
第一行输入一个整数 n。 接下来 n-1 行，每行三个整数 u，v，s(1<=u,v <=n)描述一条沟渠的状态，表示 u，v 之间有一条沟渠，s = 1 表示这条沟渠里有水，s = 2 表示这条沟渠干了。
★数据输出
第一行输出一个整数 k 表示最少的浇灌次数 20%：n < 10 40%: n < 100 100%:n < 100000
具体代码
点击查看代码
#include<iostream>
using namespace std;
int n;
const int N=100010;
int cnt=0,head[N],flag[N],sum[N];
struct tree{
int u;//起点
int v;//终点
int w;//权值
int next;//起点相同，上一条边的编号
}trees[N];
/*void init()
{
cnt=0;
head[N]=-1;
}*/
void add_edge(int u,int v,int w)
{
cnt++;
trees[cnt].u=u;
trees[cnt].v=v;
trees[cnt].w=w;
trees[cnt].next=head[u];
head[u]=cnt;
}
void dfs(int u,int fa,int w)
{
for(int i=head[u];i;i=trees[i].next)
{
int son=trees[i].v;
if(son==fa)
continue;
dfs(son,u,trees[i].w);
if(flag[son]) flag[u]=1;
sum[u]+=sum[son];
}
if(flag[u]||w){}
else
{
flag[u]++;
sum[u]++;
}
}
int main()
{
cin>>n;
int u,v,s;
for(int i=1;i<n;i++)
{
cin>>u>>v>>s;
//cout<<u<<v<<s<<endl;
if(s==2) s=0;
add_edge(u,v,s);
add_edge(v,u,s);
}
dfs(1,0,-1);
cout<<sum[1];
}
本代码来自kawaii的水水子，感谢！！！
————————————————
参考：
CSDN博主「sugarbliss」的原创文章
原文链接：https://blog.csdn.net/sugarbliss/article/details/86495945
