POJ 3728 The merchant （LCA）

最新推荐文章于 2019-08-19 12:26:53 发布

原创最新推荐文章于 2019-08-19 12:26:53 发布 · 451 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#LCA

图论专栏收录该内容

33 篇文章

订阅专栏

本文介绍了一种使用离线Tarjan算法解决最大收益路径问题的方法，通过并查集和DFS套DFS的过程，针对每个询问点对u和v，找到它们的最低公共祖先，进而计算从u到v的最大收益。该方法通过记录回溯过程中的最大和最小收益，最终得出每一对询问的最大收益。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：有5W个点构成的一棵树，有相应点权（即这个地方此商品的价格），有5w次询问（u,v）,每次询问，商人u-->v，能最多赚多少钱。他可以从任意个点买卖。

解：

离线tarjan+一些处理。

首先，要明白tarjan的过程和并查集的过程（说白了就是dfs套dfs），在回溯的过程中处理。

对于一个询问，假设u,v的LCA是f那么有三种可能，一个是从u到f 买卖了。一个是从f到v买卖了，一个是从u到f之间买了,从v到f卖了从u到f 我们称为up，从f到v我们称为down，而从u到f买然后在f到v卖就是求u到f的最小值和f到v的最大值。

我们在tarjan的过程中，在求（u,v）的lca,时，第一次用并查集，我们可以机智的记录此回溯过程中的最大值和最小值，然后再tarjan回溯过程中我们再来更新ans。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 50005
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
int n,q,num,numq;
int fa[MAXN],vis[MAXN],val[MAXN];
int p[MAXN],pq[MAXN];
int mx[MAXN],mi[MAXN];
int ans[MAXN],up[MAXN],down[MAXN];
vector<int>st[MAXN],ed[MAXN],ID[MAXN];
struct edge
{
    int en,next,id;
}E[MAXN*2],edges[MAXN*2];
int max(int x,int y,int z)
{
    return max(x,max(y,z));
}
void init()
{
    memset(p,-1,sizeof(p));
    memset(pq,-1,sizeof(pq));
    num=numq=0;
    memset(vis,0,sizeof(vis));
    memset(ans,0,sizeof(ans));
    memset(up,0,sizeof(up));//u-->fa中最好的答案
    memset(down,0,sizeof(down));//fa-->v中最好的答案
    for(int i=0;i<MAXN;i++)
    {
        st[i].clear();
        ed[i].clear();
        ID[i].clear();
        fa[i]=i;
    }
}
void add(int st,int en)
{
    E[num].en=en;
    E[num].next=p[st];
    p[st]=num++;
}
void Add(int st,int en,int id)
{
    edges[numq].en=en;
    edges[numq].next=pq[st];
    edges[numq].id=id;
    pq[st]=numq++;
}
int findfa(int x)
{
    int  y=fa[x];
    if(x!=fa[x])
    fa[x]=findfa(fa[x]);
    /******/
    //这两句话在求到u,v的lca后，再次find的时候起作用
    up[x]=max(up[x],up[y],mx[y]-mi[x]);
    down[x]=max(down[x],down[y],mx[x]-mi[y]);
    /**********/
    mx[x]=max(mx[x],mx[y]);//在找到祖先后，回溯的时候更新
    mi[x]=min(mi[x],mi[y]);
    return fa[x];
}
void tarjan(int x)
{
    vis[x]=1;
    for(int i=pq[x];i!=-1;i=edges[i].next)
    {
        int en=edges[i].en;
        int id=edges[i].id;
        if(vis[en])
        {
            int f=findfa(en);//更新mx,mi数组
            if(id>0)
            {
                st[f].push_back(x);
                ed[f].push_back(en);
                ID[f].push_back(id);
            }
            else
            {
                st[f].push_back(en);
                ed[f].push_back(x);
                ID[f].push_back(-id);
            }
        }
    }
     for(int i=p[x];i!=-1;i=E[i].next)
    {
        int en=E[i].en;
        if(!vis[en])
        {
            tarjan(en);
            fa[en]=x;
        }
    }
    for(int i=0;i<st[x].size();i++)//x作为祖先时
    {
        int u=st[x][i];
        int v=ed[x][i];
        int id=ID[x][i];

        int a=findfa(u);
        int b=findfa(v);//更新up,down
        ans[id]=max(ans[id],max(up[u],down[v]),mx[v]-mi[u]);
    }
}
void solve()
{
    tarjan(1);
    for(int i=1;i<=q;i++)
    {
        printf("%d\n",ans[i]);
    }
}
int main()
{
    int i,u,v;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        for(i=1;i<=n;i++)
        {
            scanf("%d",&val[i]);
            mx[i]=mi[i]=val[i];
        }
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        scanf("%d",&q);
        for(i=1;i<=q;i++)
        {
            scanf("%d%d",&u,&v);
            Add(u,v,i);
            Add(v,u,-i);
        }
        solve();
    }
    return 0;
}