UVA 11354 - Bond (最小生成树 + 树链剖分)

最新推荐文章于 2019-07-25 10:16:25 发布
最新推荐文章于 2019-07-25 10:16:25 发布
阅读量3k 收藏
点赞数
分类专栏： ACM算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_zxp/article/details/40985205
版权

题目链接~~>

做题感悟：这题开始看到时感觉不是树不好处理，一想可以用 Kruskal 处理成树 ，然后就好解决了。

解题思路：

                先用 Kruskal 处理出最小生成树，然后用树链剖分 + 线段树处理就可以了。

代码：

#include<iostream>
#include<sstream>
#include<map>
#include<cmath>
#include<fstream>
#include<queue>
#include<vector>
#include<sstream>
#include<cstring>
#include<cstdio>
#include<stack>
#include<bitset>
#include<ctime>
#include<string>
#include<cctype>
#include<iomanip>
#include<algorithm>
using namespace std  ;
#define INT long long int
#define L(x)  (x * 2)
#define R(x)  (x * 2 + 1)
const int INF = 0x3f3f3f3f ;
const double esp = 0.0000000001 ;
const double PI = acos(-1.0) ;
const int mod = 1000000007 ;
const int MY = (1<<5) + 5 ;
const int MX = 100000 + 5 ;
int n ,m ,nx ,idx ,num ;
int head[MX] ,ti[MX] ,siz[MX] ,son[MX] ,father[MX] ,top[MX] ,dep[MX] ;
struct NODE
{
    int u ,v ,w ;
}e[MX] ;
struct MNODE
{
    int u ,v ,w ;
}t[MX] ;
struct Edge
{
    int u ,v ,w ,next ;
}E[MX*2] ;
void addedge(int u ,int v ,int w)
{
    E[num].v = v ; E[num].w = w ; E[num].next = head[u] ; head[u] = num++ ;
    E[num].v = u ; E[num].w = w ; E[num].next = head[v] ; head[v] = num++ ;
}
bool cmp(NODE a ,NODE b)
{
    return a.w < b.w ;
}
int find(int u)
{
    if(father[u] != u)
       return find(father[u]) ;
    else   return u ;
}
void Kruskal()
{
    nx = 1 ;
    int u ,v ,fa ,fb ;
    sort(e ,e+m ,cmp) ;
    for(int i = 0 ;i <= n ; ++i)
        father[i] = i ;
    for(int i = 0 ;i < m ; ++i)
    {
        u = e[i].u ; v = e[i].v ;
        fa = find(u) ;
        fb = find(v) ;
        if(fa != fb)
        {
            father[fa] = fb ;
            addedge(u ,v ,e[i].w) ;
            t[nx].u = u ; t[nx].v = v ; t[nx++].w = e[i].w ;
        }
    }
}
void dfs_find(int u ,int fa)
{
    dep[u] = dep[fa] + 1 ;
    father[u] = fa ;
    siz[u] = 1 ;
    son[u] = 0 ;
    for(int i = head[u] ;i != -1 ;i = E[i].next)
    {
        int v = E[i].v ;
        if(v == fa)  continue ;
        dfs_find(v ,u) ;
        siz[u] += siz[v] ;
        if(siz[son[u]] < siz[v])  son[u] = v ;
    }
}
void dfs_time(int u ,int fa)
{
    top[u] = fa ;
    ti[u] = idx++ ;
    if(son[u])   dfs_time(son[u] ,top[u]) ;
    for(int i = head[u] ;i != -1 ;i = E[i].next)
    {
        int v = E[i].v ;
        if(v == father[u] || v == son[u])  continue ;
        dfs_time(v ,v) ;
    }
}
struct node
{
    int le ,rt ,c ;
}T[MX*4] ;
void build(int i ,int le ,int rt)
{
    T[i].le = le ; T[i].rt = rt ;
    T[i].c = 0 ;
    if(le == rt)  return ;
    int Mid = (le + rt)>>1 ;
    build(L(i) ,le ,Mid) ;
    build(R(i) ,Mid+1 ,rt) ;
}
void update(int i ,int pos ,int w)
{
    if(T[i].le == T[i].rt)
    {
        T[i].c = w ;
        return ;
    }
    int Mid = (T[i].le + T[i].rt)>>1 ;
    if(pos <= Mid)   update(L(i) ,pos ,w) ;
    else     update(R(i) ,pos ,w) ;
    T[i].c = max(T[L(i)].c ,T[R(i)].c) ;
}
int section(int i ,int le ,int rt)
{
    if(T[i].le == le && T[i].rt == rt)
        return T[i].c ;
    int Mid = (T[i].le + T[i].rt)>>1 ;
    if(le > Mid)   return section(R(i) ,le ,rt) ;
    else if(rt <= Mid)  return section(L(i) ,le ,rt) ;
    else
          return max(section(L(i) ,le ,Mid) ,section(R(i) ,Mid+1 ,rt)) ;
}
int LCA(int u ,int v)
{
    int ans = 0 ;
    while(top[u] != top[v])
    {
        if(dep[top[u]] < dep[top[v]])
             swap(u ,v) ;
        ans = max(ans ,section(1 ,ti[top[u]] ,ti[u])) ;
        u = father[top[u]] ;
    }
    if(dep[u] > dep[v])  swap(u ,v) ;
    if(u != v)
        ans = max(ans ,section(1 ,ti[u]+1 ,ti[v])) ;
    return ans ;
}
int main()
{
    int u ,v ,Q ;
    bool first = false ;
    while(~scanf("%d%d" ,&n ,&m))
    {
        if(first) puts("") ;
        first = true ;
        num = 0 ;
        memset(head ,-1 ,sizeof(head)) ;
        for(int i = 0 ;i < m ; ++i)
           scanf("%d%d%d" ,&e[i].u ,&e[i].v ,&e[i].w) ;
        Kruskal() ;
        dep[1] = siz[0] = 0 ;
        dfs_find(1 ,1) ;
        idx = 1 ;
        dfs_time(1 ,1) ;
        build(1 ,1 ,n) ;
        for(int i = 1 ;i < nx ; ++i)
        {
            if(dep[t[i].u] < dep[t[i].v])
                swap(t[i].u ,t[i].v) ;
            update(1 ,ti[t[i].u] ,t[i].w) ;
        }
        scanf("%d" ,&Q) ;
        for(int i = 0 ;i < Q ; ++i)
        {
            scanf("%d%d" ,&u ,&v) ;
            printf("%d\n" ,LCA(u ,v)) ;
        }
    }
    return 0 ;
}

倍增法 （类似RMQ）

代码：

#include<iostream>
#include<sstream>
#include<map>
#include<cmath>
#include<fstream>
#include<queue>
#include<vector>
#include<sstream>
#include<cstring>
#include<cstdio>
#include<stack>
#include<bitset>
#include<ctime>
#include<string>
#include<cctype>
#include<iomanip>
#include<algorithm>
using namespace std  ;
#define INT long long int
#define L(x)  (x * 2)
#define R(x)  (x * 2 + 1)
const int INF = 0x3f3f3f3f ;
const double esp = 0.0000000001 ;
const double PI = acos(-1.0) ;
const int mod = 1000000007 ;
const int MY = (1<<5) + 5 ;
const int MX = 100000 + 5 ;
const int S = 20 ;
int n ,m ,idx ,num ,nx ;
int value[MX][25] ,p[MX][25] ,ti[MX] ,father[MX] ,dep[MX] ,head[MX] ;
struct TEMP
{
    int u ,v ,w ;
}A[MX] ;
struct Edge
{
    int v ,w ,next ;
}E[MX*2] ;
bool cmp(TEMP a ,TEMP b)
{
    return a.w < b.w ;
}
int find(int u)
{
    if(father[u] != u)
       return  find(father[u]) ;
    return u ;
}
void addedge(int u ,int v ,int w)
{
    E[num].v = v ; E[num].w = w ; E[num].next = head[u] ; head[u] = num++ ;
    E[num].v = u ; E[num].w = w ; E[num].next = head[v] ; head[v] = num++ ;
}
void Kruskal()
{
    nx = 1 ;
    int fa ,fb ;
    sort(A ,A+m ,cmp) ;
    for(int i = 0 ;i <= n ; ++i)
        father[i] = i ;
    for(int i = 0 ;i < m ; ++i)
    {
        fa = find(A[i].u) ;
        fb = find(A[i].v) ;
        if(fa != fb)
        {
            father[fa] = fb ;
            addedge(A[i].u ,A[i].v ,A[i].w) ;
        }
    }
}
void dfs_find(int u ,int fa ,int w)
{
    dep[u] = dep[fa] + 1 ;
    p[u][0] = fa ;
    value[u][0] = w ;
    for(int i = 1 ;i <= S ; ++i)
    {
        p[u][i] = p[p[u][i-1]][i-1] ;
        value[u][i] = max(value[u][i-1] ,value[p[u][i-1]][i-1]) ;
    }
    for(int i = head[u] ;i != -1 ;i = E[i].next)
    {
        int v = E[i].v ;
        if(v == fa)    continue ;
        dfs_find(v ,u ,E[i].w) ;
    }
}
int LCA(int u ,int v)
{
    int ans = 0 ;
    if(dep[u] > dep[v])  swap(u ,v) ;
    if(dep[u] < dep[v])
    {
        int d = dep[v] - dep[u] ;
        for(int i = 0 ;i <= S ; ++i)
          if(d&(1<<i))
          {
              ans = max(ans ,value[v][i]) ;
              v = p[v][i] ;
          }
    }
    if(u != v)
    {
        for(int i = S ;i >= 0 ; --i)
          if(p[u][i] != p[v][i])
          {
              ans = max(ans ,value[u][i]) ;
              ans = max(ans ,value[v][i]) ;
              u = p[u][i] ;
              v = p[v][i] ;
          }
        ans = max(ans ,value[u][0]) ;
        ans = max(ans ,value[v][0]) ;
    }
    return ans ;
}
void init()
{
    num = 0 ;
    memset(head ,-1 ,sizeof(head)) ;
    memset(ti ,0 ,sizeof(ti)) ;
    memset(value ,0 ,sizeof(value)) ;
    memset(p ,0 ,sizeof(p)) ;
    memset(dep ,0 ,sizeof(dep)) ;
}
int main()
{
    //freopen("input.txt" ,"r" ,stdin) ;
    int u ,v ,Q ;
    bool first = false ;
    while(~scanf("%d%d" ,&n ,&m))
    {
        if(first)  puts("") ;
        first = true ;
        init() ;
        for(int i = 0 ;i < m ; ++i)
           scanf("%d%d%d" ,&A[i].u ,&A[i].v ,&A[i].w) ;
        Kruskal() ;
        dep[1] = 0 ;
        dfs_find(1 ,1 ,0) ;
        scanf("%d" ,&Q) ;
        while(Q--)
        {
            scanf("%d%d" ,&u ,&v) ;
            printf("%d\n" ,LCA(u ,v)) ;
        }
    }
    return 0 ;
}















 

Linux猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
uva11354-最小生成树+无根树转有根树+LCA
一个蒟蒻的博客
11-11 224
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5+5; int pre[maxn]; int Findpre(int x){return pre[x]==x? x : Findpre(pre[x]);} struct MSTEdge{ int u,v,w; bool operator &...
ifcfg-bond0
08-11
Linux系统下网卡聚合配置mode4标准
UVA-11354
常胜将军的博客
05-31 380
题意：最小瓶颈路，给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。 思路一：并查集（按秩合并），求一个最小生成树， 任意两点在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 但是n和q都太大， 如果直接顺着树走，每次询问最大复杂度O(n)， 那么复杂度高达O(n^2)，会超时。 并查集在用了路径压缩之后效...
UVA 11354 Bond
Step by step
09-25 730
题意： 给定一个无向带权图，有一些询问，问u，v点之间的路径上最大边权值的最小为多少？也就是问u，v之间的最小瓶颈路的最大边长为？ 思路： 首先的话，求出最小生成树( 瓶颈树的求法，不会自行百度 )，这样树上点u，v之间的路径唯一，且路径上的最大值即为答案，所以问题就转化为了如何快速求解u，v之间路径的最大边权。 解决上面问题的做法就是倍增法。类似于区间RMQ问题，只不过转化为树上
UVA 11354 - Bond（最小生成树+LCA）
weixin_30530523的博客
09-08 95
题目链接 https://cn.vjudge.net/problem/UVA-11354 【题意】 给定nnn个点，mmm条边的无向图，每条边有一个权值。要求回答若干组询问，每个询问包含一个起点sss和一个终点ttt，要求找到一条从sss到vvv的路径，使得途径所有边的最大边权最小 n&lt;=50000,m&lt;=100000n&...
UVA 11354 Bond(最小生成树+LCA倍增)
qq_33901573的博客
01-01 491
这题本来想用Prim来求最小瓶颈路的，但是n太大了，所以用LCA倍增来求。 #include #include #include #include using namespace std; const int maxn=50000+5; const int maxm=100000+5; const int logmax=20; const int inf=1000000000; int fa[m
One-bond gho-one-bond reduction
12-16
"一键GHO 一键还原" 是一种在个人计算机领域中常用的数据恢复技术，主要用于快速恢复系统到一个已知的良好状态。这种技术对于普通用户来说非常方便，因为它简化了复杂的系统恢复过程，使得非专业人员也能轻松操作。...
algo-green-bond
04-07
标题“algo-green-bond”可能指的是一个与算法和绿色债券相关的项目或软件。在这个场景下，我们可以探讨几个关键概念：算法、绿色债券以及它们在IT领域的应用。 首先，让我们了解什么是算法。算法是一系列精确的...
james-bond-project
05-31
签出项目后，请在项目目录中运行以下行， java -jar target/james-bond-project-1.0-SNAPSHOT.jar server src\external\conf\james-bond-config.yml 除此之外，Bootstrap 和 AngularJS JavaScript 框架也被用于制作...
pry-bond:pry-bond 通过 `bond` ruby​​gem 在 pry 中提供输入完成
07-11
pry 的默认输入完成是从 IRB 继承的，但是 bond 通过诸如类的 gem 提供了更多的可扩展性选项。 特征通过bond rubygem 在 pry 中提供输入完成。 提供enable-bond! 用于在 repl 会话中切换到绑定完成的命令。 提供...
带权无向图
09-17
关于c 的数据结构 图方面得东西 可以对图有好的了解
uva 11354 - Bond(树链剖分)
不慌不忙、不急不躁
10-18 1325
题目链接：uva 11354 - Bond 题目大意：给定一张图，每次询问两个节点路径上进过边的危险值的最大值的最小值。 解题思路：首先建立最小生成数，然后根据这棵树做树链剖分。 #include #include #include #include using namespace std; const int maxn = 50005; const int INF = 0
UVA 11354 - Bond（并查集-按秩合并）
AC_Arthur的专栏
02-15 3518
题目链接：点击打开链接 题意：给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。 思路：首先，我们可以发现，如果求一个最小生成树， 那么任意两点， 在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 但是n和q都太大， 如果直接顺着树走，每次询问最大复杂度O(n)， 那么复杂度高达O(n^2)，会超时。  
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（最小瓶颈路=最小生成树+LCA）
Rotepad的博客
07-25 213
题目： 题意：给定q个查询，每个查询包括u，求u到v的路上所有走过的边中的最大值最小，也就是最小瓶颈路 题意分析：因为是个m条边的图，并且最小瓶颈路包括在最小生成树中（因为最小生成树上任意两个点能互相到，并且最短的边都在上面）有两种情况： 1.数据比较小的时候，我们可以先建立一棵最小生成树，然后在树上dfs 2.优化：建立完最小生成树（注意不要用路径...
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 (最小生成树+LCA
twh233的算法blog
09-23 190
题目链接 题意：给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。   做法：首先考虑到需要最大危险度最小，那么对于一个无向图很容易想到最小生成树，其次如果我生成最小生成树之后进行LCA更新其路径最大值，那么即可解决本题。   /// .-~~~~~~~~~-._ ...
最小生成树+LCA+uva11354
龙崎的专栏
08-13 894
B NEXT Generation Contest 4 Time Limit – 8 secs Bond   Once again, James Bond is on his way tosaving the world. Bond's latest mission requires him to travel between seve
用python画出GG-bond这几个字
最新发布
05-31
以下是用Python绘制“GG-bond”字样的代码： ```python import turtle # 创建画布 canvas = turtle.Screen() canvas.bgcolor("white") # 创建画笔 pen = turtle.Turtle() pen.speed(0) pen.color("black") pen....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Linux猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值