HDU 2586 How far away ? (初学LCA)

原创 2015年07月07日 20:01:14

How far away ?

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7739    Accepted Submission(s): 2769


Problem Description
There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this "How far is it if I want to go from house A to house B"? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path("simple" means you can't visit a place twice) between every two houses. Yout task is to answer all these curious people.
 

Input
First line is a single integer T(T<=10), indicating the number of test cases.
  For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k(0<k<=40000).The houses are labeled from 1 to n.
  Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.
 

Output
For each test case,output m lines. Each line represents the answer of the query. Output a bland line after each test case.
 

Sample Input
2 3 2 1 2 10 3 1 15 1 2 2 3 2 2 1 2 100 1 2 2 1
 

Sample Output
10 25 100 100
 


大致题意:求树上任意两点间的距离,显然就是u,v到根的距离减去他们的LCA到根的距离


由于刚学了LCA 用了三种LCA的方法求了


方法一:离线算法tarjan

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 40000+1000;
int head[N];
int fst[N];
struct Edge
{
    int v,w,nxt,id;
}es[N<<1],qury[444];
int cnt,qc;
int ans[222];
int fa[N],ance[N];
void inline add_query(int u,int v,int id)
{
    qury[qc].v=v;
    qury[qc].id=id;
    qury[qc].nxt=fst[u];
    fst[u]=qc++;
    qury[qc].v=u;
    qury[qc].id=id;
    qury[qc].nxt=fst[v];
    fst[v]=qc++;
}
void inline add_edge(int u,int v,int w)
{
    es[cnt].w=w;
    es[cnt].v=v;
    es[cnt].nxt=head[u];
    head[u]=cnt++;
    es[cnt].v=u;
    es[cnt].w=w;
    es[cnt].nxt=head[v];
    head[v]=cnt++;
}
int n,m;
bool vis[N];
int getf(int x)
{
    return x==fa[x]? x: fa[x]=getf(fa[x]);
}
void Merge(int u,int v)
{
    fa[getf(u)]=getf(v);
}
void LCA(int u,int pa)
{
    ance[u]=fa[u]=u;
    for(int i=head[u];~i;i=es[i].nxt)
    {
        int v=es[i].v;
        if(v==pa) continue;
        LCA(v,u);
        Merge(u,v);
        ance[getf(v)]=u;
    }
    vis[u]=1;
    for(int i=fst[u];~i;i=qury[i].nxt)
    {
        int v=qury[i].v;
        if(vis[v]) ans[qury[i].id]=ance[getf(v)];
    }
}
int dp[N];
void makedp(int u,int pa)
{
    for(int i=head[u];~i;i=es[i].nxt)
    {
        int v=es[i].v,w=es[i].w;
        if(v==pa) continue;
        dp[v]=dp[u]+w;
        makedp(v,u);
    }
}
void ini()
{
    memset(head,-1,sizeof(head));
    memset(fst,-1,sizeof(fst));
    cnt=qc=0;
    memset(vis,0,sizeof(vis));
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        ini();
        scanf("%d%d",&n,&m);
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
        }
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_query(u,v,i);
        }
        LCA(1,1);
        makedp(1,1);
        for(int i=0;i<m;i++)
        {
            int j=i<<1;
            printf("%d\n",dp[qury[j].v]+dp[qury[j^1].v]-2*dp[ans[i+1]]);
        }
    }
    return 0;
}

方法二:BFS倍增跳表算法

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int N = 40000+1000;
int head[N];
struct Edge
{
    int v,w,nxt;
}es[N<<1];
int cnt;
inline void add_edge(int u,int v,int w)
{
    es[cnt].v=v;
    es[cnt].w=w;
    es[cnt].nxt=head[u];
    head[u]=cnt++;
    es[cnt].v=u;
    es[cnt].w=w;
    es[cnt].nxt=head[v];
    head[v]=cnt++;
}

int dp[N];

int dep[N];
bool vis[N];
int pa[N][20];
void bfs()
{
    queue<int>q;
    q.push(1);
    pa[1][0]=1;
    vis[1]=1;
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=1;i<20;i++) pa[u][i]=pa[pa[u][i-1]][i-1];
        for(int i=head[u];~i;i=es[i].nxt)
        {
            int v=es[i].v,w=es[i].w;
            if(vis[v]==0)
            {
                vis[v]=1;
                dp[v]=dp[u]+w;
                pa[v][0]=u;
                dep[v]=dep[u]+1;
                q.push(v);
            }
        }
    }
}
int LCA(int u,int v)
{
    if(dep[u]>dep[v]) swap(u,v);
    for(int det=dep[v]-dep[u],i=0;det;i++,det>>=1)
        if(det&1) v=pa[v][i];
    if(v==u) return v;
    for(int i=20-1;i>=0;i--)
        if(pa[u][i]!=pa[v][i]) v=pa[v][i],u=pa[u][i];
    return pa[u][0];
}
int n,m;
void ini()
{
    memset(head,-1,sizeof(head));
    cnt=0;
    memset(vis,0,sizeof(vis));
    dp[1]=0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        ini();
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
        }
        bfs();
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int lcav = LCA(u,v);
            int ans = dp[u]+dp[v]-2*dp[lcav];
            printf("%d\n",ans);
        }
    }
    return 0;
}


方法三:基于dfs的RMQ(dfs的vs记录的时间戳不是开始进入的时间戳和退出此点的时间戳,而是整个dfs路径的时间戳,每个点都可能经过2次以上,不过由于枝叶只经过一次,可以证明总次数不超过2*MAX_V)

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int N = 40000+1000;
int head[N];
struct Edge
{
    int v,w,nxt;
}es[N<<1];
int cnt;
inline void add_edge(int u,int v,int w)
{
    es[cnt].v=v;
    es[cnt].w=w;
    es[cnt].nxt=head[u];
    head[u]=cnt++;
    es[cnt].v=u;
    es[cnt].w=w;
    es[cnt].nxt=head[v];
    head[v]=cnt++;
}

int dp[N];
int index;
int vs[N*2],id[N],dep[N];
int lca[N*2][20];
bool vis[N];
void dfs(int u,int h)
{
    vis[u]=1;
    id[u]=++index;
    vs[index]=u;
    dep[u]=h;
    for(int i=head[u];~i;i=es[i].nxt)
    {
        int v=es[i].v,w=es[i].w;
        if(vis[v]) continue;
        dp[v]=dp[u]+w;
        dfs(v,h+1);
        vs[++index]=u;
    }
}

int mm[N];
void ini()
{
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    cnt=index=0;
    dp[1]=0;
}
int n,m;
int main()
{
    mm[0]=-1;
    for(int i=1;i<=N-1;i++)mm[i]= (((i-1)&i)==0)? mm[i-1]+1:mm[i-1];
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        ini();
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
        }
        dfs(1,0);
        for(int i=1;i<=index;i++) lca[i][0]=vs[i];
        for(int j=1;j<20;j++)
            for(int i=1;i+(1<<j)-1<=index;i++)
            {
                int a=lca[i][j-1],b=lca[i+(1<<(j-1))][j-1];
                lca[i][j] = dep[a]<dep[b] ? a:b;
            }

        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int l=min(id[u],id[v]);
            int r=max(id[u],id[v]);
            int k=mm[r-l+1];
            int a=lca[l][k],b=lca[r-(1<<k)+1][k];
            int lcav = dep[a]<dep[b]? a:b;
            int ans = dp[u]+dp[v]-2*dp[lcav];
            printf("%d\n",ans);
        }
    }
    return 0;
}



版权声明:本文为博主原创文章,未经博主允许不得转载。

HDU 2222 Keywords Search (初学AC自动机)

我是通过http://wenku.baidu.com/view/4e70ccc38bd63186bcebbcb9.html的第二篇学会的 这篇也总结的很好,附带很多经典的习题http://www.cp...

一类有关序列的技巧问题

问题一:http://bestcoder.hdu.edu.cn/contests/contest_showproblem.php?cid=601&pid=1005 我们有一个数列A1,A2...An...

HDU 2586 How far away ?(LCA模板 最近公共祖先啊)

HDU 2586 How far away ?(LCA模板 最近公共祖先啊)

[LCA Problem] hdu2586 How far away ?

LCA即:Lowest Common Ancestor,最近公共祖先,也就是一棵树中两个节点(这是最常用的,更普遍的,可以拓展到多个节点)同处于以另外某个节点为根的子树中,并且该根结点必须尽量靠近这两...

hdu 2586 How far away ? lca 在线和离线算法

题意:给出一棵n个节点的树,m次询问,找出u和v的距离 思路:每次对u和v找到他们的lca,并且设定一个数据机构,dis[i]表示i到根的距离,那么u和v的距离等于:dp[u] + dp[v] -...

HDU---2586-How far away(LCA)

How far away ?Crawling in process... Crawling failed Time Limit:1000MS     Memory Limit:32768KB  ...

How far away? - HDU 2586 - LCA

链接:  http://acm.hdu.edu.cn/showproblem.php?pid=2586题目:Problem Description There are n houses in the...

hdu 2586 How far away ?(LCA 求两点距离)

How far away ? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) ...
  • WEYuLi
  • WEYuLi
  • 2013年08月18日 20:35
  • 592

HDU2586 How far away ? LCA_Tarjan解法

How far away ? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) ...
  • FTQOOO
  • FTQOOO
  • 2016年02月26日 15:55
  • 310

HDU 2586 How far away ? (LCA模板题 Tarjan算法求最小公共祖先)

How far away ? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:HDU 2586 How far away ? (初学LCA)
举报原因:
原因补充:

(最多只允许输入30个字)