uva11354 最小瓶颈路及其应用

最新推荐文章于 2019-05-31 08:46:30 发布
最新推荐文章于 2019-05-31 08:46:30 发布
阅读量516 收藏
点赞数 1
分类专栏： acm_图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013514182/article/details/42674873
版权

关键词：LCA，最小瓶颈路，树上路径问题、次小生成树

询问任意两点间最小瓶颈路（最大边最小）

法一：

1.dp[u][v]：MST上u，v路径最小瓶颈路 O(n^2)

2.每组询问输出dp[u][v] O(q)

本题n最大可取50000，此法不可取

法二：

1.anc[u][i]：MST有根树中，u的第2^i个祖先；maxcost[u][i]：u到第2^i个祖先路径上的瓶颈（最长边） O(n*logn)

2.每组询问，查找u和v分别到它们公共祖先路径上的瓶颈的最大值 O(logn*q)

询问复杂度上升，但是可以接受。

心得：树上路径问题。先转化为有根树，再用LCA解决多组询问问题（前提是一般dp的预处理复杂度较高，无法完成，而LCA预处理复杂度较低）

应用：边权减小，询问MST变化（n很大，无法O(n^2)预处理）


变题：给定一棵树，每个顶点有一个权值，询问某两点路径上的最大权值（n<=50000，q<=100000)

1.建立有根树,边权定义为子节点的点权，只有根节点附加权值 O(n)

2.同上求anc[u][i]和maxcost[u][i] O(n*logn)

3.询问时，加一个特判，如果两点公共祖先是根节点，则需要比较ans和根节点权值的大小，取较大值即可 O(q*logn)



#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<math.h>
#define ll long long
#define sf scanf
#define pf printf
#define INF 1<<29
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
#define maxn 50010
#define maxm 100010
const ll mol=1000000007;
using namespace std;

int n,m,q;
struct Node{
    int u,v,w;
    bool operator<(const Node&rhs)const{
        return w<rhs.w;
    }
}node[maxm<<1];
struct Edge{
    int to,next,w;
}edge[maxn<<2];
int head[maxn],tot,mst;
int p[maxn];
int father[maxn],depth[maxn],cost[maxn];
int anc[maxn][30],maxcost[maxn][30];

void add(int u,int v,int w){
    edge[tot].to=v,edge[tot].w=w,edge[tot].next=head[u],head[u]=tot++;
}

int Find(int x){ return (p[x]==x)?x:Find(p[x]); }

void kruscal(){
    for(int i=1;i<=n;i++) p[i]=i;
    sort(node+1,node+m+1);
    mem(head,-1),tot=0,mst=0;
    for(int i=1;i<=m;i++){
        int u=node[i].u,v=node[i].v,w=node[i].w;
        int x=Find(u),y=Find(v);
        if(x!=y){
            p[x]=y;mst+=w;
            add(u,v,w),add(v,u,w);
        }
    }
}

void root(int u,int fa,int w){
    father[u]=fa,cost[u]=w;
    if(fa!=-1)  depth[u]=depth[fa]+1;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to,w=edge[i].w;
        if(v!=fa) root(v,u,w);
    }
}

void preprocess(){
    for(int i=1;i<=n;i++){//大括号位置打错了TAT...
        anc[i][0]=father[i],maxcost[i][0]=cost[i];
        for(int j=1;(1<<j)<=n;j++) anc[i][j]=-1;
    }
        for(int j=1;(1<<j)<=n;j++)
            for(int i=1;i<=n;i++)
                if(anc[i][j-1]!=-1){//判断条件很重要！
                    anc[i][j]=anc[anc[i][j-1]][j-1];
                    maxcost[i][j]=max(maxcost[i][j-1],maxcost[anc[i][j-1]][j-1]);
                }
}

int query(int u,int v){
    if(depth[u]<depth[v]) swap(u,v);//交换u,v,而不是交换u,v的深度
    int log,ans=-INF;//记录u深度的二进制最大位数
    for(log=0;(1<<log)<=depth[u];log++); log--;
    for(int i=log;i>=0;i--)//上升到同一高度
        if(depth[u]-(1<<i)>=depth[v]) { ans=max(ans,maxcost[u][i]);u=anc[u][i]; }
    if(u==v) return ans;//v是u的祖先---特判！！！
    for(int i=log;i>=0;i--)//同步上升到公共祖先节点的子节点
        if(anc[u][i]!=-1&&anc[u][i]!=anc[v][i]){
            ans=max(ans,maxcost[u][i]),u=anc[u][i];
            ans=max(ans,maxcost[v][i]),v=anc[v][i];
        }
    ans=max(ans,cost[u]),ans=max(ans,cost[v]);
    return ans;
}

int main(){
    //freopen("a.txt","r",stdin);
    int t=0;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(t!=0) printf("\n");//输出问题---最后一组不能输出换行，换行必须写在前面
        t++;
        for(int i=1;i<=m;i++) scanf("%d%d%d",&node[i].u,&node[i].v,&node[i].w);
        kruscal();
        depth[1]=0; root(1,-1,0);
        preprocess();
        scanf("%d",&q);
        while(q--){
            int u,v; scanf("%d%d",&u,&v);
            printf("%d\n",query(u,v));
        }
    }
}


利用最小瓶颈路结论可以求出次小生成树

O(nlogn)预处理，O(mlogn)询问

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define maxm 1000000
#define maxn 110
#define rad 10000
#define INF 1<<28
#define ll long long
#define rad 10000
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;

int t,n,m,mst;

struct Node{
    int u,v,w;
    bool operator<(const Node&rhs)const{
        return w<rhs.w;
    }
}node[maxn*maxn];

struct Edge{
    int to,next,w;
}edge[maxn*maxn];
int head[maxn],tot,p[maxn],vis[maxn][maxn],fa[maxn],cost[maxn];
int maxc[maxn][20],maxc2[maxn][20],anc[maxn][20],depth[maxn];

void add(int u,int v,int w) { edge[tot].to=v,edge[tot].next=head[u],edge[tot].w=w,head[u]=tot++; }

int Find(int u) { return p[u]==u?u:(p[u]=Find(p[u])); }

void kruscal(){
    for(int i=1;i<=n;i++) p[i]=i;
    mst=0,mem(vis,0),mem(head,-1),tot=0;
    for(int i=1;i<=m;i++){
        int x=Find(node[i].u),y=Find(node[i].v);
        if(x!=y){
            p[x]=y,mst+=node[i].w;
            vis[node[i].u][node[i].v]=vis[node[i].v][node[i].u]=1;
            add(node[i].u,node[i].v,node[i].w),add(node[i].v,node[i].u,node[i].w);
        }
    }
}

void dfs(int u,int f,int w){
    cost[u]=w,fa[u]=f,depth[u]=(f==-1)?0:(depth[f]+1);
    for(int i=i=head[u];i!=-1;i=edge[i].next)
        if(edge[i].to!=f) dfs(edge[i].to,u,edge[i].w);
}

void process(){
    for(int i=1;i<=n;i++){
        anc[i][0]=fa[i],maxc[i][0]=cost[i],maxc2[i][0]=cost[i];
        for(int j=1;(1<<j)<n;j++) anc[i][j]=-1;
    }
    for(int j=1;(1<<j)<n;j++)
        for(int i=1;i<=n;i++)
            if(anc[i][j-1]!=-1){
                int a=anc[i][j-1];
                anc[i][j]=anc[a][j-1];
                maxc[i][j]=max(maxc[i][j-1],maxc[a][j-1]);
            }
}

int query(int u,int v){
    int tmp,log,i;
    if(depth[u]<depth[v]) swap(u,v);
    for(log=1;(1<<log)<=depth[u];log++); log--;
    int ans=-INF;
    for(int i=log;i>=0;i--) if(depth[u]-depth[v]>=(1<<i)) { ans=max(ans,maxc[u][i]);u=anc[u][i]; }
    if(u==v) return ans;
    for(int i=log;i>=0;i--)
        if(anc[u][i]!=-1&&anc[u][i]!=anc[v][i]){
            ans=max(maxc[u][i],ans),u=anc[u][i];
            ans=max(maxc[v][i],ans),v=anc[v][i];
        }
    ans=max(ans,cost[u]),ans=max(ans,cost[v]);
    return ans;
}

int main(){
    //freopen("a.txt","r",stdin);
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
            scanf("%d%d%d",&node[i].u,&node[i].v,&node[i].w);
        sort(node+1,node+m+1);
        kruscal();
        dfs(1,-1,0);//转化为有根树
        process();//倍增法预处理x的第i个祖先及路径上的最长边和次长边
        int ans=INF;
        for(int i=1;i<=m;i++){
            int u=node[i].u,v=node[i].v,w=node[i].w;
            if(!vis[u][v]){
                int tmp=mst+w-query(u,v);
                if(tmp<ans) ans=tmp;
            }
        }
        printf("%d %d\n",mst,ans);
    }
}

求出最长边和严格次长边解决严格次小生成树问题

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define maxm 500000
#define maxn 100100
#define rad 10000
#define INF 1<<28
#define ll long long
#define rad 10000
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;

int t,n,m,mst;

struct Node{
    int u,v,w;
    bool operator<(const Node&rhs)const{
        return w<rhs.w;
    }
}node[maxm<<1];

struct Edge{
    int to,next,w;
}edge[maxm<<1];
int head[maxn],tot,p[maxn],fa[maxn],cost[maxn];
int maxc[maxn][20],maxc2[maxn][20],anc[maxn][20],depth[maxn];
int max1,max2;
bool vis[maxm];

void add(int u,int v,int w) { edge[tot].to=v,edge[tot].next=head[u],edge[tot].w=w,head[u]=tot++; }

int Find(int u) { return p[u]==u?u:(p[u]=Find(p[u])); }

void kruscal(){
    for(int i=1;i<=n;i++) p[i]=i;
    mst=0,mem(vis,0),mem(head,-1),tot=0;
    for(int i=1;i<=m;i++){
        int x=Find(node[i].u),y=Find(node[i].v);
        if(x!=y){
            p[x]=y,mst+=node[i].w,vis[i]=1;
            add(node[i].u,node[i].v,node[i].w),add(node[i].v,node[i].u,node[i].w);
        }
    }
}

void dfs(int u,int f,int w){
    cost[u]=w,fa[u]=f,depth[u]=(f==-1)?0:(depth[f]+1);
    for(int i=i=head[u];i!=-1;i=edge[i].next)
        if(edge[i].to!=f) dfs(edge[i].to,u,edge[i].w);
}

void process(){
    for(int i=1;i<=n;i++){
        anc[i][0]=fa[i],maxc[i][0]=cost[i],maxc2[i][0]=0;
        for(int j=1;(1<<j)<n;j++) anc[i][j]=-1;
    }
    for(int j=1;(1<<j)<n;j++)
        for(int i=1;i<=n;i++)
            if(anc[i][j-1]!=-1){
                int a=anc[i][j-1];
                anc[i][j]=anc[a][j-1];
                maxc[i][j]=max(maxc[i][j-1],maxc[a][j-1]);
                if(maxc[i][j-1]==maxc[a][j-1]) maxc2[i][j]=max(maxc2[i][j-1],maxc2[a][j-1]);
                else if(maxc[i][j-1]>maxc[a][j-1]) maxc2[i][j]=max(maxc2[i][j-1],maxc[a][j-1]);
                else maxc2[i][j]=max(maxc[i][j-1],maxc2[a][j-1]);
            }
}

void cal(int u,int i){
    u=anc[u][i],max1=max(max1,maxc[u][i]);
    if(max1==maxc[u][i]) max2=max(max2,maxc2[u][i]);
    else if(max1<maxc[u][i]) max2=max(max1,maxc2[u][i]);
    else max2=max(max2,maxc[u][i]);
}

void cal2(int x){
    if(x>max2&&x<max1) max2=x;
    if(x>max1) max2=max1,max1=x;
}

void query(int u,int v){
    if(depth[u]<depth[v]) swap(depth[u],depth[v]);
    int d=depth[u]-depth[v],tmp=0;
    for(int i=0;i<16;i++) if(d&(1<<i)) cal(u,i);//更新路径最大和严格次大值
    //for(int i=16;i>=0;i--) if((tmp+=(1<<i))<=d) cal(u);//另一种写法
    if(u==v) return;
    for(int i=16;i>=0;i--) if(anc[u][i]!=-1&&anc[u][i]!=anc[v][i]) cal(u,i),cal(v,i);
    cal2(cost[u]),cal2(cost[v]);
}

int main(){
    //freopen("a.txt","r",stdin);
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
            scanf("%d%d%d",&node[i].u,&node[i].v,&node[i].w);
        sort(node+1,node+m+1);
        kruscal();
        dfs(1,-1,0);//转化为有根树
        process();//倍增法预处理x的第i个祖先及路径上的最长边和次长边
        int ans=INF;
        for(int i=1;i<=m;i++){
            int u=node[i].u,v=node[i].v,w=node[i].w,tmp;
            max1=0,max2=0;
            if(!vis[i]){
                query(u,v);//求MST上任意两点的最长边和严格次长边
                if(max1==w) tmp=mst+w-max2;
                else tmp=mst+w-max1;
                ans=min(ans,tmp);
            }
        }
        printf("%d\n",ans);
}



lshacm
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
UVa11887 Tetrahedrons and Spheres
04-20
【标题】"UVa11887 Tetrahedrons and Spheres" 是一个编程竞赛题目，源自著名的在线算法竞赛平台UVa（University of Valladolid）。这个题目要求参赛者解决与几何形状——四面体和球体相关的问题。 【描述】"测试...
UVa1348/LA3310 Tomato Automata
最新发布
06-14
该题目源于2005年的SEERC（South Eastern European Regional Contest）比赛，旨在考察参赛者的状态机设计与动态规划等算法应用能力。 "Tomato Automata"问题的核心在于构建一个自动机模型来处理给定的输入序列，...
UVA 11354 - Bond 最小树/LCA/瓶颈路
Azarath Metrion Zinthos
09-25 1162
----------------------- Once again, James Bond is on his way to saving the world. Bond's latest mission requires him to travel between several pairs of cities in a certain country.   The countr
uva11354
guoshiyuan484的博客
08-12 256
#include #include #include #include using namespace std; struct edgee { int from, to, cost; edgee(int from, int to, int cost) :from(from), to(to), cost(cost) {} edgee() {} bool operator<( edgee
UVA-11354
常胜将军的博客
05-31 380
题意：最小瓶颈路，给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。 思路一：并查集（按秩合并），求一个最小生成树， 任意两点在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 但是n和q都太大， 如果直接顺着树走，每次询问最大复杂度O(n)， 那么复杂度高达O(n^2)，会超时。 并查集在用了路径压缩之后效...
Uva 11354
Infinity的博客
03-03 680
Uva 11354题意是给出n个点，m条边的图，并有q个询问(s,t)，输出s到t的最右路径下的最大边权值。 用Kruskal先求出最小瓶颈生成树，并深搜将其转化为有根树，并在同时记录下每个点的深度和父结点。计算出anc[i][j]以及maxcost[i][j],分别表示i的第2^j级祖先，i到其第2^j级祖先的最长边长度，j=0时表示父节点。 那么存在递推关系anc[i][j]=anc[anc
Bond UVA - 11354
FTM's Blog
05-23 281
Bond UVA - 11354题目大意：n个点m条边的图，q次询问，找到一条从s到t的一条边，使所有边的最大危险系数最小。题解：使最大的危险系数尽量小，答案一定是最小生成树上的边。 为了快速回答询问，用LCA倍增法记录s和t到他们最近公共祖先的最大值。Code：#include <iostream> #include <cstdio> #include <cstring> #include <a
uva.rar_UVA_机器人足球
09-24
机器人足球的底层代码，提供到开发环境中去，希望大家一起分享
AIML.zip_UVA_UVA 499
09-20
标题中的"AIML.zip_UVA_UVA 499"暗示了这是一个与计算机编程相关的压缩文件，特别是针对解决UVA（University of Virginia）在线判题系统中的第499道题目。UVA在线判题系统是程序员提升算法和编程技能的一个平台，...
UVa1313/LA2693 Ghost Busters
04-14
【标题】"UVa1313/LA2693 Ghost Busters"是一个编程竞赛题目，来源于UVA（University of Virginia）在线判题系统，同时也出现在了NEERC（North Eurasia East Regional Contest）2002的比赛中。这类题目通常是为训练...
【UVA11354】Bond
清疚的博客
10-18 263
题意   给定无向带权的Graph=Graph=（V，EV，E）   现在有QQ组询问：uu到vv的所有路径的最小的最大边权 解法 树链剖分：   一开始看到最小的最大边权，我还往二分上想……复杂度O（Q∗nlognQ*nlogn），直接TT飞   然后认真想了想，其实啊，这有一个很明显的结论：最小的最大边权必定是最小生成树上
uva 11354 Bond
iwi
03-14 292
题目：Bond 题意：给出一张无向图和m个询问x y，输出x，y之间的最小瓶颈路。思路：用lca倍增求最小瓶颈路。注意：当x和y的lca是y时要特判。代码：#include&lt;bits/stdc++.h&gt; using namespace std; #define maxn 50000 #define maxm 100000 #define maxl 20 struct Edge { ...
UVA 11354 Bond（MST + LCA）
diary_yang的专栏
08-17 1242
n50000个询问，每次求q->p的瓶颈路。 其实求瓶颈路数组maxcost[u][v]有用邻接矩阵prim的方法。但是对于这个题的n，邻接矩阵是存不下的。。。所以默默的抄了一遍大白书上的算法。。。先用kruskal求MST，然后对于MST树，每次询问求p和q的LCA,在求LCA的过程中顺便求出瓶颈路。。。 #include #include #include #include #includ
UVA11354 Bond
cx422803902的专栏
02-21 1189
很明显满足这个条件的路径就是最小生成树上链接两个点的那条唯一的路径 但是题目有50000个询问，如果单纯的在MST上DFS求值则每次查询的复杂度都是O(n),最后可能高达50000*50000 如果组成一棵有根树，每个点记录了父节点及与父节点距离，则任意两个点肯定会有一个共同祖先，所求的值就是两个点到共同祖先路径上最大边中的较大者， 我们只要记录每个点的深度，先将深度调到一样大，然后
UVA 11354 Bond
Step by step
09-25 730
题意： 给定一个无向带权图，有一些询问，问u，v点之间的路径上最大边权值的最小为多少？也就是问u，v之间的最小瓶颈路的最大边长为？ 思路： 首先的话，求出最小生成树( 瓶颈树的求法，不会自行百度 )，这样树上点u，v之间的路径唯一，且路径上的最大值即为答案，所以问题就转化为了如何快速求解u，v之间路径的最大边权。 解决上面问题的做法就是倍增法。类似于区间RMQ问题，只不过转化为树上
UVA 11354 - Bond（树链剖分）
Remilia's
09-30 1091
UVA 11354 - Bond 题目链接 题意：给定一个图，要求每次询问两点，求出这两点间路径最大危险系数最小 思路：先求最小生成树，在生成树上每次询问求LCT就可以了，利用树链剖分求解 代码： #include #include #include #include using namespace std; #define lson(x) ((x<<1)+
Uva 11354 Bond（最小生成树+LCA）
哆啦AC梦的博客
08-22 449
题目地址：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2339 思路： 寻找s到t路径上最大权值最小的值。则该路径必在最小生成树上：最小生成树上为权值尽可能短的n-1条边，若该路径上最小的最大权值不在最小生成树上，则此权值会比最小生成树上的权值大（
UVA 11354 - Bond (最小生成树 + 树链剖分)
Linux猿
11-10 3016
最小生成树 + 树链剖分
robocup uva
11-28
RoboCup UVA是荷兰阿姆斯特丹大学的一个机器人足球比赛。UVA代表“Universiteit van Amsterdam”，即阿姆斯特丹大学的荷文名字。RoboCup UVA是RoboCup联合会下属的一个赛事，旨在推动机器人技术和人工智能在足球领域...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值