poj3728之离线LCA+dp思想/RMQ+LCA(非常好的题目)

最新推荐文章于 2021-11-06 16:00:00 发布
最新推荐文章于 2021-11-06 16:00:00 发布
阅读量105 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/shuaihui520/p/9703223.html
本文探讨了一种结合树形动态规划与最近公共祖先（LCA）算法的问题解决策略，旨在优化路径上的商品交易利润计算。通过分析树状结构中的节点属性，如最大利润、最小成本等，实现路径上最佳买卖点的快速定位。

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

题意很简单

给一个树(n < 5w) 每个点有个权值，代表商品价格

若干个询问(5w)

 

对每个询问，问的是从u点走到v点(简单路径），商人在这个路径中的某点买入商品，然后在某点再卖出商品，   最大可能是多少

注意一条路径上只能买卖一次，先买才能卖

 

  • *分析:先求出点u,v的最近公共祖先f,然后求u->f->v的利润最大值maxval
  •  
    对于这个maxval可能有三种情况:
  •  
    1:maxval是u->f的maxval
  •  
    2:maxval是f->v的maxval
  •  
    3:maxval是u->f的最小w[i]减去f->v的最大w[i]
  •  
    分析到这很明显需要设置4个变量来求maxval:
  •  
    up[u]表示u->f的最大maxval
  •  
    down[u]表示f->u的最大maxval
  •  
    maxw[u]表示u-f的最大w[i]
  •  
    minw[u]表示u-f的最小w[i]
  •  
    所以maxval=max(max(up[u],down[v]),maxw[v]-minw[u]);
  •  
    现在问题就是如何快速的求出这四个变量,在这里我们可以对u,v的LCA(u,v)进行分类解决
  •  
    对于LCA(u,v)是f的询问全部求出,然后再求LCA(u,v)是f的父亲的询问
  •  
    这样当我们求LCA(u,v)是f的父亲的询问的时候就可以借用已经求出的LCA(u,v)是f的询问
  •  
    的结果,这样就不用反复去求u->f的那四个变量值,u->father[f]也能快速求出
  •  
    这个变化主要在寻找father[v]这个过程中进行,具体看代码
  •   
    /*分析:先求出点u,v的最近公共祖先f,然后求u->f->v的利润最大值maxval
对于这个maxval可能有三种情况:
1:maxval是u->f的maxval
2:maxval是f->v的maxval
3:maxval是u->f的最小w[i]减去f->v的最大w[i]
分析到这很明显需要设置4个变量来求maxval:
up[u]表示u->f的最大maxval
down[u]表示f->u的最大maxval
maxw[u]表示u-f的最大w[i]
minw[u]表示u-f的最小w[i]
所以maxval=max(max(up[u],down[v]),maxw[v]-minw[u]);
现在问题就是如何快速的求出这四个变量,在这里我们可以对u,v的LCA(u,v)进行分类解决
对于LCA(u,v)是f的询问全部求出,然后再求LCA(u,v)是f的父亲的询问
这样当我们求LCA(u,v)是f的父亲的询问的时候就可以借用已经求出的LCA(u,v)是f的询问
 的结果,这样就不用反复去求u->f的那四个变量值,u->father[f]也能快速求出
 这个变化主要在寻找father[v]这个过程中进行,具体看代码 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;
 
const int MAX=50000+10;
int n,m,size;
int uu[MAX],vv[MAX],ww[MAX],sum[MAX];
int up[MAX],down[MAX],maxw[MAX],minw[MAX],father[MAX];
int head[MAX],head2[MAX],head3[MAX];
bool mark[MAX];
 
struct Edge{
    int v,id,next;
    Edge(){}
    Edge(int V,int ID,int NEXT):v(V),id(ID),next(NEXT){}
}edge[MAX*2],edge2[MAX*2],edge3[MAX*2];
 
void Init(int num){
    for(int i=0;i<=num;++i)head[i]=head2[i]=head3[i]=-1,mark[i]=false;
    size=0; 
}
void InsertEdge(int u,int v,int id){
    edge[size]=Edge(v,id,head[u]);
    head[u]=size++;
}
void InsertEdge2(int u,int v,int id){
    edge2[size]=Edge(v,id,head2[u]);
    head2[u]=size++;
}
void InsertEdge3(int u,int v,int id){
    edge3[size]=Edge(v,id,head3[u]);
    head3[u]=size++;
}
int findset(int v){
    if(v == father[v])return father[v];
    int fa=father[v];
    father[v]=findset(father[v]);
    up[v]=max(max(up[v],up[fa]),maxw[fa]-minw[v]);
    down[v]=max(max(down[v],down[fa]),maxw[v]-minw[fa]);
    maxw[v]=max(maxw[v],maxw[fa]);
    minw[v]=min(minw[v],minw[fa]);
    return father[v];
}
void LCA(int u){
    mark[u]=true;
    father[u]=u;
    for(int i=head2[u];i != -1;i=edge2[i].next){//对LCA(u,v)进行分类 
        int v=edge2[i].v,id=edge2[i].id;
        if(!mark[v])continue;
        int f=findset(v);
        InsertEdge3(f,v,id);
    }
    for(int i=head[u];i != -1;i=edge[i].next){
        int v=edge[i].v;
        if(mark[v])continue;
        LCA(v);
        father[v]=u;
    }
    for(int i=head3[u];i != -1;i=edge3[i].next){
        int id=edge3[i].id;
        findset(uu[id]);
        findset(vv[id]);
        sum[id]=max(max(up[uu[id]],down[vv[id]]),maxw[vv[id]]-minw[uu[id]]);
    }
}
int main(){
    int u,v;
    while(~scanf("%d",&n)){
        Init(n);
        for(int i=1;i<=n;++i){
            scanf("%d",ww+i);
            up[i]=down[i]=0;
            maxw[i]=minw[i]=ww[i];
        }
        for(int i=1;i<n;++i){
            scanf("%d%d",&u,&v);
            InsertEdge(u,v,i);
            InsertEdge(v,u,i); 
        }
        size=0;
        scanf("%d",&m);
        for(int i=0;i<m;++i){
            scanf("%d%d",&uu[i],&vv[i]);
            InsertEdge2(uu[i],vv[i],i);
            InsertEdge2(vv[i],uu[i],i); 
        }
        size=0;
        LCA(1);
        for(int i=0;i<m;++i)printf("%d\n",sum[i]);
    }
    return 0;
}
    View Code

     

RMQ做法

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;
 
const int MAX=50000+10;
int n,m,size,top;
int uu[MAX],vv[MAX],ww[MAX],anc[MAX];
int up[MAX][20],down[MAX][20],maxw[MAX][20],minw[MAX][20],deep[MAX];
int head[MAX],head2[MAX],bin[MAX],stack[MAX],mp[MAX][20],father[MAX];
bool mark[MAX];
 
struct Edge{
    int v,id,next;
    Edge(){}
    Edge(int V,int ID,int NEXT):v(V),id(ID),next(NEXT){}
}edge[MAX*2],edge2[MAX*2];
 
void Init(int num){
    for(int i=0;i<=num;++i)head[i]=head2[i]=-1,mark[i]=false;
    size=top=0;
}
void InsertEdge(int u,int v,int id){
    edge[size]=Edge(v,id,head[u]);
    head[u]=size++;
} 
void InsertEdge2(int u,int v,int id){
    edge2[size]=Edge(v,id,head2[u]);
    head2[u]=size++;
}
void dfs(int u,int father,int k){
    deep[u]=k;
    for(int i=head[u];i != -1;i=edge[i].next){
        int v=edge[i].v;
        if(v == father)continue;
        dfs(v,u,k+1);
    }
}
void RMQ(int u,int father){
    stack[++top]=u;
    int fa=stack[top-1];
    up[u][0]=down[u][0]=0;
    maxw[u][0]=minw[u][0]=ww[u];
    for(int i=1;bin[i]<=top;++i){//2^i<=top
        fa=stack[top-bin[i-1]];
        up[u][i]=max(max(up[u][i-1],up[fa][i-1]),maxw[fa][i-1]-minw[u][i-1]);
        down[u][i]=max(max(down[u][i-1],down[fa][i-1]),maxw[u][i-1]-minw[fa][i-1]);
        maxw[u][i]=max(maxw[u][i-1],maxw[fa][i-1]);
        minw[u][i]=min(minw[u][i-1],minw[fa][i-1]);
        mp[u][i]=stack[top-bin[i]];
    }
    for(int i=head[u];i != -1;i=edge[i].next){
        int v=edge[i].v;
        if(v == father)continue;
        RMQ(v,u);
    }
    --top;
}
int findset(int v){
    if(v != father[v])father[v]=findset(father[v]);
    return father[v];
}
void LCA(int u){
    mark[u]=true;
    father[u]=u;
    for(int i=head2[u];i != -1;i=edge2[i].next){
        int v=edge2[i].v,id=edge2[i].id;
        if(!mark[v])continue;
        anc[id]=findset(v);
    }
    for(int i=head[u];i != -1;i=edge[i].next){
        int v=edge[i].v;
        if(mark[v])continue;
        LCA(v);
        father[v]=u;
    }
}
int search(int x){
    int i=0;
    while(bin[i+1]<=x)++i;
    return i;
}
int Minw(int u,int anc){
    int i=search(deep[u]-deep[anc]+1);
    if(bin[i] == deep[u]-deep[anc]+1)return minw[u][i];
    return min(minw[u][i],Minw(mp[u][i],anc));
}
int Maxw(int u,int anc){
    int i=search(deep[u]-deep[anc]+1);
    if(bin[i] == deep[u]-deep[anc]+1)return maxw[u][i];
    return max(maxw[u][i],Maxw(mp[u][i],anc));
}
int Down(int u,int anc){
    int i=search(deep[u]-deep[anc]+1);
    if(bin[i] == deep[u]-deep[anc]+1)return down[u][i];
    int downfa=Down(mp[u][i],anc);
    downfa=max(downfa,down[u][i]);
    int minwfa=Minw(mp[u][i],anc);
    return max(downfa,maxw[u][i]-minwfa); 
}
int UP(int u,int anc){
    int i=search(deep[u]-deep[anc]+1);
    if(bin[i] == deep[u]-deep[anc]+1)return up[u][i];
    int upfa=UP(mp[u][i],anc);
    upfa=max(upfa,up[u][i]);
    int maxwfa=Maxw(mp[u][i],anc);
    return max(upfa,maxwfa-minw[u][i]);
}
int main(){
    bin[0]=1;
    for(int i=1;bin[i-1]<MAX;++i)bin[i]=bin[i-1]*2;
    int u,v;
    while(~scanf("%d",&n)){
        Init(n);
        for(int i=1;i<=n;++i)scanf("%d",ww+i);
        for(int i=1;i<n;++i){
            scanf("%d%d",&u,&v);
            InsertEdge(u,v,i);
            InsertEdge(v,u,i);
        }
        size=0;
        scanf("%d",&m);
        for(int i=0;i<m;++i){
            scanf("%d%d",uu+i,vv+i);
            InsertEdge2(uu[i],vv[i],i);
            InsertEdge2(vv[i],uu[i],i);
        }
        dfs(1,-1,1);
        RMQ(1,-1);
        LCA(1);    
        for(int i=0;i<m;++i){
            int upmax=UP(uu[i],anc[i]),downmax=Down(vv[i],anc[i]);    
            int Minww=Minw(uu[i],anc[i]),Maxww=Maxw(vv[i],anc[i]);
            printf("%d\n",max(max(upmax,downmax),Maxww-Minww));
        }
    }
    return 0;
}
/*
7
300
11
11
21
10
31
222
1 2
2 3
3 4
4 5
2 6
1 7
1
5 6
*/
View Code

 

转载于:https://www.cnblogs.com/shuaihui520/p/9703223.html

LCA的离线算法（Tarjan）与在线算法（RMQ）详解
dmR
12-08 1602
一、 LCA问题的简介 LCA问题（Least Common Ancestors，最近公共祖先问题），是指给定一棵有根树T，给出若干个查询LCA(u, v)（通常查询数量较大），每次求树T中两个 顶点x和y的最近公共祖先。 询问：LCA(x, y)，即求x与y的最近公共祖先。 题目描述：通常是先给定一棵有根树，然后询问（两种询问方式，下文会提及）。       二、LCA题目的分类
POJ 3728
A1823085974的博客
03-31 156
http://poj.org/problem?id=3278 题目大意就是在同一坐标轴上给你一个人的坐标，一个牛的坐标，而人的运动每一次运动有三种方式，一种是后退1，一种是前进1，还有一种是坐标翻倍，问最短的运动次数 这是我所接触的第一个BFS也就是广度优先搜索，在网上看了几篇博客，发现一篇的是最好理解的，然后我就照着做了，也A了 1 #include <s...
poj 3728(LCA + dp)
weixin_33834075的博客
10-11 136
题目链接：http://poj.org/problem?id=3728 思路：题目的意思是求树上a -&gt; b的路径上的最大收益（在最小值买入，在最大值卖出）。 我们假设路径a - &gt; b 之间的LCA(a, b) = f, 并且另up[a]表示a - &gt; f之间的最大收益，down[a]表示f - &gt; a之间的最大收益，dp_max[a]表示a - &gt; f...
poj3728 The merchant
weixin_30257433的博客
10-20 98
Time Limit:3000MS Memory Limit:65536K Total Submissions:3761 Accepted:1268 Description There areNcities in a country, and there is one and only one simple path between e...
poj3728
weixin_30647065的博客
09-29 154
【描述】 有 N 城 市在一个国家,有一个且只有一个简单的路径每一对城市之间。 一个商人选择了一些路径和想赚尽可能多的钱在每个路径。 当他沿着一条路径,可以选择一个城市购买一些商品和出售他们在一个城市。 货物在所有的城市都是一样的,但价格是不同的。 现在你的任务是计算每条路径的最大利润。 【解】 这是一道树上的题目，找路径自然不必多说lca找到公共祖先路径也就找到了。但是这个题有...
LCA与RMQ相关题解1
08-03
这里同样可以利用RMQ思想，不过在初始化动态规划（DP）时，DP[i]不仅存储信息，还记录了有多少个相同的数字。这样在查询时，通过RMQ可以快速找到两个数之间的相同数字的最大数量。 【离线LCA与Tarjan算法】 POJ1470...
LCA与RMQ模板及应用解析：POJ经典题解
本文档主要涉及两个计算机科学中的经典算法问题：最近公共祖先（Lowest Common Ancestor, LCA）和范围最大值查询（Range Maximum Query, RMQ）。这些问题在数据结构和算法设计中具有重要地位。 1. **LCA问题（POJ...
ACM中的RMQ和LCA问题
01-16
在ACM（国际大学生程序设计竞赛）中，RMQ（Range Minimal Query）和LCA（Least Common Ancestor）是两种常见的数据结构问题，通常出现在树形结构或数组中。 RMQ问题指的是在一个数组中，对给定区间进行最小值查询。...
RMQ与LCA ACM必备
09-27
【RMQ（Range Minimal Query）】 RMQ，即范围最小值查询，是计算机科学中数据结构和算法设计的一个重要概念。它涉及到在一个数组或序列中寻找给定区间内的最小值。例如，对于数列3, 5, 2, 9, 1, 4, 6，我们可以查询...
POJ 3728 The merchant（在线倍增LCA）
ZSQ
07-26 971
Description n个城市构成一棵树，每个城市都有一种商品有一个固定的价格，一个商人要从一个城市到另一个城市，他会在路途中选取一个城市购买这种商品然后在之后的某个城市卖掉以赚取差价，问最大差价 Input 第一行一整数n表示城市个数，之后n个整数val[i]表示第i个城市该种商品的价格，之后n-1行每行两个整数u和v表示u城市和v城市有路径，然后输入一整数q表示查询数，每次查询输入两个整
POJ 3728 The merchant (Tarjan LCA)
= =
01-18 996
题意： 给出一棵树，有点权，5W次询问从a走到b交易一件物品能获得的最大利润(即在某个节点买入一件物品，在后面的节点卖出)。 正确理解题意花了一天多，泪奔。 解法： 设a,b的LCA为c，则答案来自a->c，c->b，或者在ac段买入在cb段卖出。容易想到信息是可以合并的，那么不妨在Tarjan用并查集求出一个询问的LCA后，顺便用并查集把路径的信息合并。TarjanLCA求lca(a,b
POJ 3728 The merchant (LCA DP)
Bell的博客
11-06 261
POJ 3728 The merchant (LCA DP) POJ - 3728 题目大意：给出一棵树，每次询问给出 u,vu,vu,v 两点，在 uuu 到 vvv 的有向路径上先后选出两个点 u′,v′u',v'u′,v′ ，令 w(v′)−w(u′)w(v')-w(u')w(v′)−w(u′) 最大。 可以想到三种情况： 在 u→lca(u,v)u\rightarrow {\rm lca}(u,v)u→lca(u,v) 的路径上买卖 在 lca(u,v)→v{\rm lca}(u,v)\right
poj 3728(LCA+并查集应用)
志当存高远
09-14 1908
The merchant Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 1520   Accepted: 434 Description
POJ 3728 The merchant(经典LCA)
albertluf的博客
03-14 359
The merchantTime Limit: 3000MS Memory Limit: 65536KTotal Submissions:5599 Accepted: 1931DescriptionThere are N cities in a country, and there is one and only one simple path between each pair of citie...
POJ - 3728 The merchant【离线LCA[倍增法]】
tystrwor的博客
08-30 377
POJ - 3728传送 题意：给定n个城市，每两个城市之间有且仅有一条路。货物在各个城市的价格不同，在一条路径中，             商人选择其 中一个城市买进货物，然后在之后的一个城市卖出货物，求所能获得的最大利润。             对于q次询问，每次询问给定两个整数表示两个城市，输出两城市之间路径所对应的最大利润。             注意最
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值