树的直径+LCA模板

连通无回路的无向图称为无向树，简称树。

树的直径：一颗树上存在的最长路径。

树形DP

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn=1e5+10;
int tot=0;
int head[maxn],nxt[maxn<<1],ver[maxn<<1],wei[maxn<<1];
//head[i]->i为起点的最后一条边的编号
//nxt[i]->i这条边上一条边的编号
//ver[i]->当前边的终点
//wei[i]->当前边的权值
void addedge(int u,int v,int w)//建无向图
{
    nxt[++tot]=head[u],head[u]=tot,ver[tot]=v,wei[tot]=w;
    nxt[++tot]=head[v],head[v]=tot,ver[tot]=u,wei[tot]=w;
}
int dist[maxn],ans=0;
bool vis[maxn];
void dfs(int u)
{
    vis[u]=true;
    for(int i=head[u];i!=-1;i=nxt[i])
    {
        int v=ver[i],w=wei[i];
        if(vis[v])continue;
        dfs(v);
        ans=max(ans,dist[u]+dist[v]+w);//经过u的直径，最长的即为树的直径
        dist[u]=max(dist[u],dist[v]+w);//表示u到其子树叶子的最远距离
    }
}
int main()
{
    int u,v,w;
    memset(head,-1,sizeof(head));
    while(~scanf("%d%d%d",&u,&v,&w))
    {
        addedge(u,v,w);
    }
    dfs(1);
    cout<<ans<<endl;
    return 0;
}

两次dfs

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=1e5+10;
int tot=0;
int head[maxn],nxt[maxn<<1],ver[maxn<<1],wei[maxn<<1];
//head[i]->i为起点的最后一条边的编号
//nxt[i]->i这条边上一条边的编号
//ver[i]->当前边的终点
//wei[i]->当前边的权值
void addedge(int u,int v,int w)//建无向图
{
    nxt[++tot]=head[u],head[u]=tot,ver[tot]=v,wei[tot]=w;
    nxt[++tot]=head[v],head[v]=tot,ver[tot]=u,wei[tot]=w;
}
bool vis[maxn];
int dis[maxn],ans,num;
void bfs(int x)
{
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    queue<int>q;
    q.push(x);
    vis[x]=1;
    ans=0;
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=head[u];i!=-1;i=nxt[i])
        {
            int v=ver[i];
            if(vis[v])continue;
            vis[v]=1;
            dis[v]=wei[i]+dis[u];
            if(ans<dis[v]){
                ans=dis[v];
		num=v;
            }
            q.push(v);
        }
    }
}
int main()
{
    int u,v,w;
    tot=0;
    memset(head,-1,sizeof(head));    //head初始化为-1
    while(~scanf("%d%d%d",&u,&v,&w))
    {
        addedge(u,v,w);
    }
    bfs(1);                //以第1个点为起点找到离它最远的点
    bfs(num);              //以该点为起点找到最长的路径即为直径
    printf("%d\n",ans);
    return 0;
}

LCA

在线，树上倍增

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=50010;
int tot,t;
int head[maxn],nxt[maxn<<1],ver[maxn<<1],wei[maxn<<1];
int dist[maxn],fat[maxn][20],dep[maxn];
//dep[i]:表示结点i在树中的深度.（根结点的深度为1）
//dist[i]:表示节点x到树根的距离.
//fat[i][j]:表示结点i的第2^j个父亲.
void addedge(int u,int v,int w)
{
    nxt[++tot]=head[u],head[u]=tot,ver[tot]=v,wei[tot]=w;
    nxt[++tot]=head[v],head[v]=tot,ver[tot]=u,wei[tot]=w;
}
void bfs()              //预处理
{
    queue<int>q;
    q.push(1);dep[1]=1;
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=head[u];i;i=nxt[i])
        {
            int v=ver[i];
            if(dep[v])continue;
            dep[v]=dep[u]+1;        //孩子的深度等于父结点的深度+1
            dist[v]=dist[u]+wei[i];
            fat[v][0]=u;
            for(int j=1;j<=t;j++)//v的第2^(j-1)祖先的第2^(j-1)祖先就是v的第2^j祖先
                fat[v][j]=fat[fat[v][j-1]][j-1];
            q.push(v);
        }
    }
}
int lca(int x,int y)            //找到x和y的最近公共祖先
{
    if(dep[x]>dep[y])swap(x,y); //保证y的深度大于x
    for(int i=t;i>=0;i--)       //令y深度减小，使深度相同
        if(dep[fat[y][i]]>=dep[x])
            y=fat[y][i];
    if(x==y)return x;
    for(int i=t;i>=0;i--)       //倍增，x、y一起往上跳
        if(fat[x][i]!=fat[y][i])
            x=fat[x][i],y=fat[y][i];
    return fat[x][0];
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        int n,m;scanf("%d%d",&n,&m);
        t=(int)(log(n)/log(2))+1;   
        tot=0;
        memset(head,0,sizeof(head));
        memset(dep,0,sizeof(dep));
        int u,v,w;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
        }
        bfs();
        while(m--)
        {
            int x,y;scanf("%d%d",&x,&y);
            printf("%d\n",dist[x]+dist[y]-2*dist[lca(x,y)]);
        }
    }
    return 0;
}

离线，tarjan算法

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=50010;
int tot;
int head[maxn],nxt[maxn<<1],ver[maxn<<1],wei[maxn<<1];
int fa[maxn],dist[maxn],vis[maxn],lca[maxn],ans[maxn];
vector<int>query[maxn],query_id[maxn];
void addedge(int u,int v,int w)
{
    nxt[++tot]=head[u],head[u]=tot,ver[tot]=v,wei[tot]=w;
    nxt[++tot]=head[v],head[v]=tot,ver[tot]=u,wei[tot]=w;
}
void add_query(int x,int y,int id)
{
    query[x].push_back(y),query_id[x].push_back(id);
    query[y].push_back(x),query_id[y].push_back(id);
}
int get(int x)
{
    if(x==fa[x])return x;
    return fa[x]=get(fa[x]);
}
void tarjan(int u)
{
    vis[u]=1;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=ver[i];
        if(vis[v])continue;
        dist[v]=dist[u]+wei[i];
        tarjan(v);
        fa[v]=u;
    }
    for(int i=0;i<query[u].size();i++)
    {
        int v=query[u][i],id=query_id[u][i];
        if(vis[v]==2){
            int lca=get(v);
            ans[id]=min(ans[id],dist[u]+dist[v]-2*dist[lca]);
        }
    }
    vis[u]=2;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        int n,m;scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            head[i]=0;fa[i]=i,vis[i]=0;
            query[i].clear(),query_id[i].clear();
        }
        tot=0;
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
        }
        for(int i=1;i<=m;i++)
        {
            int x,y;scanf("%d%d",&x,&y);
            if(x==y)ans[i]=0;
            else{
                add_query(x,y,i);
                ans[i]=1<<30;
            }
        }
        tarjan(1);
        for(int i=1;i<=m;i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}

模板题

poj1330

注意两个点的公共祖先与根节点的选取有关。

建立有向图，找到下标最小的入度为0的点作为根节点。

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=20010;
int tot,t;
int head[maxn],nxt[maxn<<1],ver[maxn<<1];
int fat[maxn][20],dep[maxn];
bool vis[maxn];
void addedge(int u,int v)
{
    nxt[++tot]=head[u],head[u]=tot,ver[tot]=v;
}
int n;
void bfs() 
{
    int k;
    for(int i=1;i<=n;i++)       //找到入度为0的点中下标最小的
        if(!vis[i]){k=i;break;}
    queue<int>q;
    q.push(k);dep[k]=1;        //令k为根节点
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=head[u];i;i=nxt[i])
        {
            int v=ver[i];
            if(dep[v])continue;
            dep[v]=dep[u]+1;
            fat[v][0]=u;
            for(int j=1;j<=t;j++)
                fat[v][j]=fat[fat[v][j-1]][j-1];
            q.push(v);
        }
    }
}
int lca(int x,int y)           
{
    if(dep[x]>dep[y])swap(x,y);
    for(int i=t;i>=0;i--)      
        if(dep[fat[y][i]]>=dep[x])
            y=fat[y][i];
    if(x==y)return x;
    for(int i=t;i>=0;i--)      
        if(fat[x][i]!=fat[y][i])
            x=fat[x][i],y=fat[y][i];
    return fat[x][0];
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        t=(int)(log(n)/log(2))+1;
        tot=0;
        memset(head,0,sizeof(head));
        memset(dep,0,sizeof(dep));
        memset(vis,0,sizeof(vis));
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);//处理为有向图
            addedge(u,v);
            vis[v]=1;
        }
        bfs();
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
    return 0;
}