链式前向星与Tarjan算法

链式前向星

           图的存储方法有很多如：邻接矩阵、邻接表和边集数组，除此之外还有链式前向星。链式前向星是一种静态链表存储，用边集数组和邻接表相结合，可以快速访问一个顶点的所有邻接点。

           链式前向星存储包含两种结构

edge[]；边集数组，edge[i]表示第i条边
head[]; 头节点数组，head[i]存储以i为起点的上一条边的编号（即：在edge[]中的下标，随着边的不断插入，一个固定的下标i对应的head[i]的值会发生改变，具体看后面例子体会。）

struct node{
    int to;//该边的到达顶点的编号（范围1到n）
    int next;//与该边起点相同的上一条边在edge[]中的下标，如果是第一条边，则为默认值-1或其他
    int w;//变的权重
}edge[maxn<<1];//边数一般至少为maxn*maxn,因为无向图一条边对应两个方向，相当于插入两条边。 

对于无向图

           

 

每一条边的结构如下图：

         

例如，一个无向图如下所示：

        

按照以下顺序建立链式前向星：

       （1）输入 1 2 5

创建一条边,顶点1——2 ，边的权重为5，创建第一条边edge[0]，如图所示

         

          然后将该边链接到1号节点的头结点(head[])中。（初始时head[]数组全部初始化为-1，也就是edge[0].next = head[1]，head[1]=0 (也就是指向该边的编号:0,edge[0]) ,也就是1号节点关联的第一条边的边号为0，如下图所示，其中虚拟箭头表示关联关系）

        head[]使用的下标从1开始，下图中的head[]应该是1到4，而不是1到5，多画了一个（粗心了，懒的重画，后面发现后也改正了，哈哈哈）

         

       接着插入边2——1，权重为5，创建第二条边edge[1],并将该边链接到2号节点的头节点中。即edge[1].next=head[2];head[2]=1;表示2号节点关联的第一条边的边号为1，如下图所示：

       

       (2) 输入 1 4 3

       创建一条边1——4，权重为3，创建第3条边edge[2],然后将该边链接到1号节点的头结点中（头插法），即edge[2].next=head[1];head[1]=2;表示1号节点关联的上一条边（上一条边是指以该节点为起点已经至少插入了一条边）为2号边，如下所示

       由于是无向图，还需插入它的反向边4——1，权值为3，创建第4条边edge[3],然后将该边链接到4号节点的头节点中。即edge[3].next=head[4];head[4]=3;表示4号节点关联的第一条边为3号边，如下图所示。

      

（3）依次输入以下三条边，创建的链式前向星，如图所示

    2 3 8     

    2 4 12

    3 4 9

    

添加一条边u v w的代码如下

//cnt初始为0，每执行一次add，cnt加1
void add(int u, int v, int w){
    edge[cnt].to = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
//如果是有向图，每输入一条边，执行一次add(u,v,w)
//如果是无向图，每输入一条边，需要执行两次：add(u,v,w);add(v,u,w);


//如何使用链式前向星访问一个节点u所有邻接点？

for(int i = head[u]; i!=-1; i=edge[i].next){
    int v = edge[i].to;//邻接点
    int w = edge[i].w;//权重
    ...

}
// 由于是头插法，for循环访问邻接点的顺序与插入顺序相反
// 和邻接表相同，由于采用头插法，所以边输入的顺序不同，创建的链式前向星也会不同

 

链式前向星的应用——tarjan算法

tarjan算法有很多，但名字都相同。这里是用来求解一棵树中，两个节点之间的距离。而求两个节点之间的距离就必须先知道最近公共祖先(Lowest Common Ancestors, LCA)

上图，节点7，9的最近公共祖先为2，tarjan算法就是用来求7 9 之间的距离，7 9 距离为5（7，9之间边的数目，若边有权重，则为边对应权重之和）。

而求解算法有很多，如暴力搜索，树上倍增，在线RMQ、离线Tarjan以及树链剖分法，下面介绍离线Tarjan算法，所谓离线是指，一次性把需要查询的情况全部输入，然后返回全部结果。在线是输入一次返回一次结果。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn=40005;
int n,m;
int head[maxn],dis[maxn],cnt;//头结点；到根节点的距离；边的编号； 
int fa[maxn],ans[maxn];fa[i]存储i的父节点；ans[i]存储第i个查询的结果；
bool vis[maxn];//访问标记
vector<int>query[maxn],query_id[maxn];//查询及编号 

struct Edge
{
	int to,c,next;
 }e[maxn<<1];
 
void add(int u,int v,int w)
{
	e[++cnt].to=v;
	e[cnt].c=w;
	e[cnt].next=head[u];
	head[u]=cnt;
}//以上与链式前向星相同

int find(int x)//并查集找祖宗，当我是我的父亲时递归结束；
{
	if(x==fa[x])
		return x;
	return fa[x]=find(fa[x]);
}
//添加查询，即找x,y之间的距离，id为输入查询的编号，从0开始
void add_query(int x,int y,int id) //边号都是唯一的，不存在x等于y的情况
{    //添加两次是因为不确定x,y谁先被访问
	query[x].push_back(y);//查找x 和 y距离
	query_id[x].push_back(id);
	query[y].push_back(x);//查找y和x的距离
	query_id[y].push_back(id);
}

void tarjan(int u)
{
    
	vis[u]=1;//标记已访问
    //以下是深度优先遍历，后序访问
	for(int i=head[u];i;i=e[i].next)//以u节点为起点，广度上遍历的顺序
	{
		int v=e[i].to,w=e[i].c;
		if(vis[v])
			continue;
		dis[v]=dis[u]+w;//与根节点的距离，从上往下求
		tarjan(v);//v为u的邻接点（在树中称：子节点），优先访问子节点
		fa[v]=u;//执行到此，v以及v的子孙节点都已经得到与根节点的距离，并且知道自己的父节点；
	}
    //此时u的父亲还是u自己，而u的子孙都已经得到与根节点的距离，并且知道父节点；

    
	for(int i=0;i<query[u].size();i++)//u相关的所有查询
	{
		int v=query[u][i];
		int id=query_id[u][i];
        //此时u已经被访问了，如果v没有被访问过的话什么也不做
		if(vis[v])
		{    //先访问的v,再访问的u
			int lca=find(v);//lca最近公共祖先
			ans[id]=dis[u]+dis[v]-2*dis[lca];//结果就是distance(u,lca)+distance(v,lca)
		}
	}
}


int main()
{
	int x,y,lca;
	
	cin>>n>>m;//n为节点数；m：查询的个数
	for(int i=1;i<=n;i++)//初始化 
	{
		head[i]=vis[i]=dis[i]=0;//初始化为0，而不是-1，都可以，下标从1开始
		fa[i]=i;//初始时，将所有节点的父亲设置为自己
		query[i].clear();
		query_id[i].clear();
	}	
	cnt=0;
	for(int i=1;i<n;i++)//输入一棵树的n-1边
	{
		int x,y,z;
		cin>>x>>y>>z;
		add(x,y,z);
		add(y,x,z);
	}
	for(int i=1;i<=m;i++)
	{
		cin>>x>>y;
		if(x==y)
			ans[i]=0;
		else
			add_query(x,y,i);
	}
	tarjan(1);
	for(int i=1;i<=m;i++)		
		cout<<ans[i]<<endl;//输出x y的距离 	
	
	return 0;
}