[洛谷]1967 货车运输(Kruskal+链式向前星+倍增LCA)

一、题目描述

二、解题思路

原来用单纯的Kruskal算法超时了，看了大神们的方法第一次学链式向前星和倍增LCA，下面详细介绍以下链式向前星和倍增LCA

三、链式向前星

链式向前星是一种加快稠密图搜索的一种方法，它是在邻接表的基础上的一种优化，它的存储结构如下：

struct node
{
	int to; 
	int next; 
}edge[maxv];

to表示边的终点，next表示与该条边的起点相同的上一条边在edge中的索引。因此下一步需要解决的问题就是如何找到上一条在edge中的位置。可以多加一个数组head[i]来记录最近的以i为起点的边在edge中的位置，head初始化为0。因此建图的函数如下：

struct node
{
	int to;
	int next;
}edge[maxv];
int head[maxn];
int cnt=1;//表示edge数组的下标，也可以表示已经存入的边数
void add(int from,int t)
{
	edge[cnt].to=t;
	edge[cnt].next=head[from];
	head[from]=cnt++;
}

我们假设输入的边的顺序为<1,2><1,3><2,3>：
① 当输入<1,2>时，edge[1].to=2，edge[1].next=head[1]=0，head[1]=1；
② 当输入<1,3>时，edge[2].to=3，edge[2].next=head[1]=1，head[1]=2；
③ 当输入<2,3>时，edge[3].to=3，edge[3].next=head[2]=0，head[2]=3。

以dfs举例说明链式向前星的遍历过程。代码如下：

void dfs(int start)
{
    vis[start]=true;
    for(int i=head[start];i!=0;i=edge[i].next) 
    { //当i==0时就表示已经没有以start为起点的可以访问的边了
    	if(!vis[edge[i].to])
        	dfs(edge[i].to);
    }
}

三、倍增LCA

LCA即最近公共祖先。例如图中F和E的最近公共祖先为B。若我们现在要找H点和E点的最近公共祖先，一个朴素的想法就是H点一步步往上跳，当跳到和E点的深度相同时，比较一下此时跳到的点是不是E点，可惜这时跳到的是D点。这个时候，就要兵分两路，从D点和E点再同时往上跳，每跳一次比较一下是不是跳到了同一个点上，如果是同一个点那么这个点就是二者的LCA，否则需要继续往上跳。但是这样一步一步往上跳也太慢了吧，那有没有什么可以加速的方法呢？二进制优化！二进制优化真是个好东西，上次学到的多重背包问题也可以使用二进制优化。
我们现在增设一个二维数组dp[i][j]，它表示第i个结点往上跳2^j步后的所在结点。二进制优化的原理是，任何一个正整数都可以表示为若干个2^k的和(k=0,1,2,…)。经过分析我们可以很容易得到如下等式：dp[i][j]=dp[dp[i][j-1]][j-1]。因此我们的初始化函数可以表示为

//fa表示每个点的父节点 
int fa[100],DP[100][20];
void init()
{
	//n为结点数，先初始化DP数组 
	for(int i=1;i<=n;i++)
		dp[i][0]=fa[i];
	//动态规划求出整个DP数组 
	for(int j=1;i<20;j++)  //一般在题目中不会有树超过2^20层吧？暂且设为20
		for(int i=1;i<=n;i++)
			DP[i][j]=DP[DP[i][j-1]][j-1];
}

寻找LCA的代码如下

//查询函数
int LCA(int a,int b)
{
    //确保a的深度大于b，便于后面操作。
	if(deep[a]<deep[b])
		swap(a,b);
    //让a不断往上跳，直到与b处于同一深度
    //若不能确保a的深度大于b，则在这一步中就无法确定往上跳的是a还是b
	for(int i=19;i>=0;i--)
	{
        //往上跳就是深度减少的过程
		if(deep[a]-1<<i>=deep[b])
			a=dp[a][i];
	}
    //若二者处于同一深度后，正好相遇，则这个点就是LCA
	if(a==b)
		return a;
    //a和b同时往上跳，从大到小遍历步长，遇到合适的就跳上去，不合适就减少步长
	for(int i=19;i>=0;i--)
	{
        //若二者没相遇则跳上去
		if(dp[a][i]!=dp[b][i])
		{
			a=dp[a][i];
			b=dp[b][i];
		}
	}
    //最后a和b跳到了LCA的下一层，LCA就是a和b的父节点
	return dp[a][0]; 
}

四、AC代码

#include<cstdio>  
#include<algorithm>  
#include<cstring>  
#include<iostream>  
#define MAXN 10005 
#define INF 999999999
using namespace std;
struct Edge1 {
    int x, y, dis;
}edge1[50005]; //题目所给的图 
struct Edge2 {
    int to, next, w;
}edge2[100005]; //最大生成树的图 
int cnt, n, m, head[MAXN], deep[MAXN], f[MAXN], fa[MAXN][21], w[MAXN][21];
bool vis[MAXN] = { false };

void addedge(int from, int to, int w)
{ //前向星存图 
    edge2[++cnt].next = head[from];  //存入同一个起点的上一条边的索引
    edge2[cnt].to = to;  //存入终点
    edge2[cnt].w = w;
    head[from] = cnt;
    return;
}

bool CMP(Edge1 x, Edge1 y)
{
    return y.dis < x.dis; //将边权从大到小排序 
}

int find(int x) {  
    if (f[x] != x) f[x] = find(f[x]);
    return f[x];
}

void kruskal()
{
    sort(edge1 + 1, edge1 + m + 1, CMP);
    for (int i = 1; i <= n; i++)
        f[i] = i;  //并查集初始化 
    for (int i = 1; i <= m; i++)
        if (find(edge1[i].x) != find(edge1[i].y)) {
            f[find(edge1[i].x)] = find(edge1[i].y);
            addedge(edge1[i].x, edge1[i].y, edge1[i].dis);
            addedge(edge1[i].y, edge1[i].x, edge1[i].dis);  //无向图，双向加边 
        }
    return;
}

void dfs(int node)
{
    vis[node] = true;
    for (int i = head[node]; i; i = edge2[i].next) { //前向星遍历 
        int to = edge2[i].to;
        if (vis[to]) continue;
        deep[to] = deep[node] + 1; //计算深度 
        fa[to][0] = node; //储存父节点 
        w[to][0] = edge2[i].w; //储存到父节点的权值 
        dfs(to);
    }
    return;
}

int lca(int x, int y)
{
    if (find(x) != find(y)) return -1; //不连通，输出-1 
    int ans = INF;
    if (deep[x] > deep[y]) swap(x, y); //保证y节点更深 
    for (int i = 20; i >= 0; i--)
        if (deep[fa[y][i]] >= deep[x]) {
            ans = min(ans, w[y][i]);  //更新最大载重（最小边权） 
            y = fa[y][i]; //y为上跳的位置 
        }
    if (x == y) return ans; //如果位置已经相等，直接返回答案 
    //寻找公共祖先 
    for (int i = 20; i >= 0; i--)
        if (fa[x][i] != fa[y][i]) {
            ans = min(ans, min(w[x][i], w[y][i])); //更新最大载重（最小边权）
            x = fa[x][i];
            y = fa[y][i]; //修改x,y位置 
        }
    ans = min(ans, min(w[x][0], w[y][0]));
    //更新此时x,y到公共祖先最大载重，fa[x][0], fa[y][0]即为公共祖先 
    return ans;
}

int main()
{
    int x, y, z, q;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        edge1[i].x = x;
        edge1[i].y = y;
        edge1[i].dis = z;
    } //储存题目所给图 
    kruskal();

    for (int i = 1; i <= n; i++) //不一定为连通图,所以需要对每个点进行收集
        if (!vis[i]) { //dfs收集信息 
            deep[i] = 1;
            dfs(i);
            fa[i][0] = i;
            w[i][0] = INF;
        }
    //LCA初始化 
    for (int i = 1; i <= 20; i++)
        for (int j = 1; j <= n; j++) {
            fa[j][i] = fa[fa[j][i - 1]][i - 1];
            w[j][i] = min(w[j][i - 1], w[fa[j][i - 1]][i - 1]);
        }
    scanf("%d", &q);
    for (int i = 1; i <= q; i++) {
        scanf("%d%d", &x, &y);
        printf("%d\n", lca(x, y)); //回答询问 
    }
    return 0;
}