2021-08-09 LCA基础

前言：crq开的基础图论里LCA没学过，所以就打算趁机学一下。

学习目标：

LCA专题训练

学习内容：

1、 TZOJ 5701: 数据结构实验：最近公共祖先
2、 TZOJ 6579: 祖孙询问
3、 TZOJ 6578: 点的距离2
4、 TZOJ 6532: 次小生成树
5、 TZOJ 6577: 暗的连锁

---

题目一：

没啥好说的倍增LCA模板题
这里我用的是dfs构建倍增数组，实际上用bfs构建更安全，不容易爆栈。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int N = 10000;
struct node
{
	int u, v, next;
}edge[N];
int cnt = 1;int n,root;
int head[N], deep[N], f[N][20];
int pre[N];
int findx(int x)
{
	return pre[x] == x ? x : findx(pre[x]);
}
void addedge(int x, int y)
{
	edge[cnt].u = x;
	edge[cnt].v = y;
	edge[cnt].next = head[x];
	head[x] = cnt++;
}
void build_tree(int p)
{
	for (int i = head[p]; i != -1; i = edge[i].next)
	{
		int will = edge[i].v;
		if (deep[will] == 0)
		{
			deep[will] = deep[p] + 1;
			f[will][0] = p;
			build_tree(will);
		}
	}
}
void init_step()
{
	for (int i = 1; i <= 19; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			f[j][i] = f[f[j][i - 1]][i - 1];
		}
	}
}
int LCA(int x, int y)
{
	if (deep[x] < deep[y])swap(x, y);
	for (int i = 19; i >= 0; i--)
	{
		if (deep[f[x][i]] >= deep[y])
		{
			x = f[x][i];
		}
	}
	if (x == y)return y;
	for (int i = 19; i >= 0; i--)
	{
		if (f[x][i] != f[y][i])
		{
			x = f[x][i], y = f[y][i];
		}
	}
	return f[x][0];
}
int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)head[i] = -1,pre[i]=i;
	for (int i = 1; i <= n; i++)
	{
		int u, num;
		scanf("%d %d", &u,&num);
		root = u;
		while (num--)
		{
			int v;
			scanf("%d", &v);
			addedge(u, v);
			addedge(v, u);
			pre[v] = u;
		}
	}
	root = findx(root);
	deep[root] = 1;
	//cout << root << endl;
	//cout << "-------" << endl;
	build_tree(root);
	
	init_step();
	
	int m;
	scanf("%d",&m);
	for (int i = 1; i <= m; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		printf("%d %d = %d\n", x, y, LCA(x, y));
	}
}

---

题目二：

使用倍增LCA也可以在O(nlogn)的时间复杂度下求解；但是如果我们使用tarjan算法的可以在O(n)的时间复杂度完成求解

#include<bits/stdc++.h>
using namespace std;
const int N=40005;
vector<int>G[N];
int depth[N],fa[N][16],q[N];
void bfs(int root)
{
    memset(depth,0x3f,sizeof depth);
    depth[0]=0;depth[root]=1;
    int hh=0,tt=0;
    q[0]=root;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(auto i:G[t])
        {
            if(depth[i]>depth[t]+1)
            {
                depth[i]=depth[t]+1;
                q[++tt]=i;
                fa[i][0]=t;
                for(int k=1;k<=15;k++)
                {
                    fa[i][k]=fa[fa[i][k-1]][k-1];
                }
            }
        }
    }
    
}
int lca(int a,int b)
{
    if(depth[a]<depth[b])swap(a,b);
    for(int k=15;k>=0;k--)
    {
        if(depth[fa[a][k]]>=depth[b])
        {
            a=fa[a][k];
        }
    }
    if(a==b)return b;
    for(int k=15;k>=0;k--)
    {
        if(fa[a][k]!=fa[b][k])
        {
            a=fa[a][k];
            b=fa[b][k];
        }
    }
    return fa[a][0];
}
int main()
{
    int n,root;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        if(b==-1)root=a;
        else
        {
            G[a].push_back(b);
            G[b].push_back(a);
        }
    }
    bfs(root);
    int m;
    scanf("%d",&m);
    while(m--)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        int p=lca(a,b);
        if(a==p)cout<<1<<endl;
        else if(b==p)cout<<2<<endl;
        else cout<<0<<endl;
    }
}

---

题目三

这里使用tarjan算法求解

#include<bits/stdc++.h>
using namespace std;
const int N=10005;
typedef pair<int,int>pii;
vector<pii>G[N];
vector<pii>query[N*2];
int res[N*2],depth[N],pre[N],st[N];
void dfs(int u,int fa)
{
    for(auto i:G[u])
    {
        int v=i.first,d=i.second;
        if(v!=fa)
        {
            depth[v]=depth[u]+d;
            dfs(v,u);
        }
    }
}
int findx(int x)
{
    return x==pre[x]?x:findx(pre[x]);
}
void tarjan(int u)
{
    st[u]=1;
    for(auto i:G[u])
    {
        int v=i.first;
        if(!st[v])
        {
            tarjan(v);
            pre[v]=u;
        }
    }
    for(auto i:query[u])
    {
        int v=i.first,id=i.second;
        if(st[v]==2)
        {
            int anc=findx(v);
            res[id]=depth[u]+depth[v]-2*depth[anc];
        }
    }
    st[u]=2;
}
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++)pre[i]=i;
    for(int i=1;i<n;i++)
    {
        int x,y,d;
        scanf("%d %d %d",&x,&y,&d);
        G[x].push_back({y,d});
        G[y].push_back({x,d});
    }
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d %d",&x,&y);
        query[x].push_back({y,i});
        query[y].push_back({x,i});
    }
    dfs(1,-1);
    tarjan(1);
    for(int i=1;i<=m;i++)printf("%d\n",res[i]);
}

---

题目四

大难题QAQ，对于我这种蒟蒻来说也太难了
1.先求出原方案的最小生成树最值。
2.对说生成的最小生成树进行构图。
【结论：有至少一个（严格）次小生成树，和最小生成树之间只有一条边的差异。】
3.对以上结论对说进行倍增优化，将所有的两点之间的最大边和次大边进行更新即可。
4.将未在生成树的边逐一加入，最后取最小的生成树。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int>pii;
const int N=100005;
const int inf=0x3f3f3f3f;
inline int read()
{
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}
struct node
{
    int a,b;
    int c;
    bool used;
    bool operator<(const node &t)const
    {
        return c<t.c;
    }
}edge[N*3];
int pre[N],n,m,depth[N],fa[N][17];
int d1[N][17],d2[N][17];
vector<pii>G[N];
inline int findx(int x)
{
    return x==pre[x]?x:findx(pre[x]);
}
LL kruskal()
{
    LL res=0;
    sort(edge+1,edge+1+m);
    for(int i=1;i<=m;i++)
    {
        int a=findx(edge[i].a),b=findx(edge[i].b),c=edge[i].c;
        if(a!=b)
        {
            pre[a]=b;
            res+=c;
            edge[i].used=true;
        }
    }
    return res;
}
void build()
{
    for(int i=1;i<=m;i++)
    {
        if(edge[i].used)
        {
            G[edge[i].a].push_back({edge[i].b,edge[i].c});
            G[edge[i].b].push_back({edge[i].a,edge[i].c});
        }
    }
}
void bfs()
{
    memset(depth,0x3f,sizeof depth);
    queue<int>q;
    depth[1]=1;depth[0]=0;
    q.push(1);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(auto i:G[u])
        {
            int v=i.first,w=i.second;
            if(depth[v]>depth[u]+1)
            {
                depth[v]=depth[u]+1;
                q.push(v);
                fa[v][0]=u;
                d1[v][0]=w;d2[v][0]=-inf;
                for(int k=1;k<=16;k++)
                {
                    int anc=fa[v][k-1];
                    fa[v][k]=fa[anc][k-1];
                    int dis[4]={d1[v][k-1],d2[v][k-1],d1[anc][k-1],d2[anc][k-1]};
                    d1[v][k]=-inf,d2[v][k]=-inf;
                    for(int p=0;p<4;p++)
                    {
                        int t=dis[p];
                        if(t>d1[v][k])d2[v][k]=d1[v][k],d1[v][k]=t;
                        else if(t!=d1[v][k]&&t>d2[v][k]) d2[v][k]=t;
                    }
                }
            }
            
        }
    }
    
}
inline int lca(int a,int b,LL w)
{
    int cnt=0;
    static int dist[N*2];
    if(depth[a]<depth[b])swap(a,b);
    for(int k=16;k>=0;k--)
    {
        if(depth[fa[a][k]]>=depth[b])
        {
            dist[cnt++]=d1[a][k];
            dist[cnt++]=d2[a][k];
            a=fa[a][k];
        }
    }
    if(a!=b)
    {
        for(int k=16;k>=0;k--)
        {
            if(fa[a][k]!=fa[b][k])
            {
                dist[cnt++]=d1[a][k];
                dist[cnt++]=d2[a][k];
                dist[cnt++]=d1[b][k];
                dist[cnt++]=d2[b][k];
                a=fa[a][k],b=fa[b][k];
            }
        }
        dist[cnt++]=d1[a][0];
        dist[cnt++]=d1[b][0];
    }
    int dist1=-inf,dist2=-inf;
    for(int i=0;i<cnt;i++)
    {
        int d=dist[i];
        if(d>dist1)dist2=dist1,dist1=d;
        else if(d!=dist1&&d>dist2)dist2=d;
    }
    if(w>dist1)return w-dist1;
    if(w>dist2)return w-dist2;
}
int main()
{
   
    n=read();m=read();
    for(int i=1;i<=n;i++)pre[i]=i;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        a=read();b=read();c=read();
        edge[i]={a,b,c};
    }
    LL w=kruskal();
    build();
    bfs();
    LL res=1e18;
    for(int i=1;i<=m;i++)
    {
        if(!edge[i].used)
        {
            res=min(res,w+lca(edge[i].a,edge[i].b,edge[i].c));
        }
    }
    printf("%lld",res);
}

---

题目五

这道题要用到树上差分：
对于两个顶点x,y;要对他们两点到其LCA上的所有边都加上a;
则引入差分数组d；公式即为d[x]+a;d[y]+a;y[p]-2*a;

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,depth[N],fa[N][17],dp[N],ans;
vector<int>G[N];
void bfs()
{
    memset(depth,0x3f,sizeof depth);
    queue<int>q;
    depth[0]=0;depth[1]=1;
    q.push(1);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(auto v:G[u])
        {
            if(depth[v]>depth[u]+1)
            {
                depth[v]=depth[u]+1;
                q.push(v);
                fa[v][0]=u;
                for(int k=1;k<=16;k++)
                {
                    fa[v][k]=fa[fa[v][k-1]][k-1];
                }
            }
        }
    }
}
int LCA(int a,int b)
{
    if(depth[a]<depth[b])swap(a,b);
    for(int k=16;k>=0;k--)
    {
        if(depth[fa[a][k]]>=depth[b])
        {
            a=fa[a][k];
        }
    }
    if(a==b)return a;
    else
    {
        for(int k=16;k>=0;k--)
        {
            if(fa[a][k]!=fa[b][k])
            {
                a=fa[a][k];
                b=fa[b][k];
            }
        }
    }
    return fa[a][0];
}
int dfs(int u,int father)
{
    int res=dp[u];
    for(auto v:G[u])
    {
        if(v!=father)
        {
            int s=dfs(v,u);
            if(s==0)ans+=m;
            else if(s==1)ans+=1;
            res+=s;
        }
    }
    return res;
}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        G[a].push_back(b);
        G[b].push_back(a);
    }
    bfs();
    for(int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        int p=LCA(a,b);
        dp[a]++;dp[b]++;dp[p]-=2;
    }
    dfs(1,-1);
    printf("%d\n",ans);
}