裸题-UVA11354_最小瓶颈路_LCA(两种写法)

最新推荐文章于 2020-02-17 10:41:26 发布
最新推荐文章于 2020-02-17 10:41:26 发布
阅读量393 收藏
点赞数
分类专栏： LCA 最短路 生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39599067/article/details/82940637
版权
最短路 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
生成树
6 篇文章 0 订阅
订阅专栏
LCA
5 篇文章 0 订阅
订阅专栏

（有任何问题欢迎留言或私聊 && 欢迎交流讨论哦

Catalog

文章目录

Problem：

 Portal传送门

 原题目描述在最下面。

 给定一个 n n n个点图， q q q次询问最小瓶颈路。

 最小瓶颈路就是在两个结点之间求一条最长边最短的路径，而次小生成树则是所有生成树中权值排名第二的生成树(可以和最小生成树相等)(当然也有一个问题是求严格的次小生成树, 那么这个就不同了)

Solution：

 裸题啊，自己敲一遍练练手咯

 倍增加 L C A LCA LCA随便搞搞。

 性质1: 最小瓶颈路的值一定在 M S T MST MST上。

 所以就在 M S T MST MST上跑一遍树上倍增，记录最大权值。

 询问的话，就在求LCA的同时，记录最大边权即可。


 当然这题也可以用Kruskal重构树写，下面附上代码。

AC_Code：
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <ctime>
#include <iostream>
#define lson(x) cw[x].l
#define rson(x) cw[x].r
using namespace std;
typedef long long LL;

const int MXN = 1e5 + 5;
const int MXE = 6e5 + 5;
const int INF = 0x3f3f3f3f;
int n, m;
int fa[MXN], FA[MXN], up[MXN][23], dis[MXN][23], dep[MXN];
int head[MXN], tot;
struct lp{
    int v, w, nex;
}cw[MXE];
struct node{
    int u, v, w;
}edge[MXE];
void init() {
    tot = -1;
    memset(head, -1, sizeof(head));
    memset(dis, 0, sizeof(dis));
}
void dfs(int u,int ba,int d) {
    fa[u] = up[u][0] = ba;
    dep[u] = d;
    for(int i = 1, cf; i < 20; ++i) {
        cf =up[u][i-1];
        up[u][i] = up[cf][i-1];
        dis[u][i] = max(dis[u][i-1],dis[cf][i-1]);
    }
    for(int i = head[u]; ~i; i = cw[i].nex) {
        int v = cw[i].v;
        if(v == ba) continue;
        dis[v][0] = cw[i].w;
        up[v][0] = u;
        dfs(v, u, d+1);
    }
}
/*int LCA(int x,int y) {
    int ans = 0;
    if(dep[x] < dep[y]) swap(x, y);
    int k = dep[x] - dep[y];
    for(int i = 0; i < 20; ++i) {
        if((1<<i)&k){
            ans = max(ans, dis[x][i]);
            x = up[x][i];
        }
    }
    if(x != y){
        for(int i = 19; i >= 0; --i) {
            if(up[x][i] != up[y][i]) {
                ans = max(ans, dis[x][i]);
                ans = max(ans, dis[y][i]);
                x = up[x][i]; y = up[y][i];
            }
        }
        ans = max(ans, max(dis[x][0],dis[y][0]));
    }
    return ans;
}*/
int LCA(int x,int y) {
    int ans = 0;
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = 19; i >= 0; --i) {
        if(dep[up[x][i]] >= dep[y]) {
            ans = max(ans, dis[x][i]);
            x = up[x][i];
        }
    }
    if(x != y){
        for(int i = 19; i >= 0; --i) {
            if(up[x][i] != up[y][i]) {
                ans = max(ans, dis[x][i]);
                ans = max(ans, dis[y][i]);
                x = up[x][i]; y = up[y][i];
            }
        }
        ans = max(ans, max(dis[x][0],dis[y][0]));
    }
    return ans;
}
void add_edge(int u,int v,int w) {
    cw[++tot].v = v; cw[tot].w = w; cw[tot].nex = head[u];
    head[u] = tot;
    cw[++tot].v = u; cw[tot].w = w; cw[tot].nex = head[v];
    head[v] = tot;
}
bool cmp(node &a, node &b) {
    return a.w < b.w;
}
int Fi(int x) {
    return FA[x] == x? x: FA[x] = Fi(FA[x]);
}
int fuck = 0;
void solve() {
    if(fuck) printf("\n");
    init();
    for(int i = 0; i < m; ++i) {
        scanf("%d%d%d", &edge[i].u,&edge[i].v,&edge[i].w);
    }
    sort(edge, edge + m, cmp);
    int CNT = 0;
    for(int i = 1; i <= n; ++i) FA[i] = i;
    for(int i  = 0; i < m; ++i) {
        int pa = Fi(edge[i].u), pb = Fi(edge[i].v);
        if(pa == pb) continue;
        FA[pb] = pa;
        add_edge(edge[i].u,edge[i].v,edge[i].w);
        CNT ++;
        if(CNT == n - 1) break;
    }
    up[1][0] = 1;
    //dis[1][0] = INF;
    dfs(1, 1, 1);
    int q, u, v;scanf("%d", &q);
    while(q--) {
        scanf("%d%d", &u, &v);
        printf("%d\n", LCA(u, v));
    }
    fuck++;
}
int main(int argc, char const *argv[]){
    while(~scanf("%d%d", &n, &m)) solve();
    return 0;
}

Problem Description：

在这里插入图片描述

LCA模板

struct lp {
    int v, nex;
    int w;
} cw[MXE];
int tot, head[MXN];
namespace LCA {
    int fa[MXN], sz[MXN], dep[MXN], son[MXN], top[MXN], dis[MXN];
    void dfs1(int u,int ba,int d) {
        dep[u] = d; fa[u] = ba; sz[u] = 1; son[u] = 0;
        for(int i = head[u], v; ~i; i = cw[i].nex) {
            v = cw[i].v;
            if(v == ba) continue;
            dis[v] = dis[u] + cw[i].w;
            dfs1(v, u, d + 1);
            sz[u] += sz[v];
            if(sz[v] > sz[son[u]]) son[u] = v;
        }
    }
    void rdfs(int u,int ba) {
        if(son[u]) {
            top[son[u]] = top[u];
            rdfs(son[u], u);
        }
        for(int i = head[u], v; ~i; i = cw[i].nex) {
            v = cw[i].v;
            if(v == ba || v == son[u]) continue;
            top[v] = v;
            rdfs(v, u);
        }
    }
    int lca(int x,int y) {
        while(top[x] != top[y]) {
            if(dep[top[x]] < dep[top[y]]) swap(x, y);
            x = fa[top[x]];
        }
        return dep[x] < dep[y]? x: y;
    }
    int query(int x, int y) {
        return dis[x] + dis[y] - 2 * dis[lca(x, y)];
    }
    void init() {
        dfs1(1, 1, 1);
        top[1] = 1;
        rdfs(1, 1);
    }
}
namespace LCA {
    int dis[MXN], up[MXN][20], lens[MXN];
    void dfs(int u, int ba, int d) {
        up[u][0] = ba; lens[u] = d;
        for(int i = 1; i < 20; ++i) up[u][i] = up[up[u][i-1]][i-1];
        for(int i = head[u], v; ~i; i = cw[i].nex) {
            v = cw[i].v;
            if(v == ba) continue;
            dis[v] = dis[u] + cw[i].w;
            dfs(v, u, d + 1);
        }
    }
    int lca(int x, int y) {
        if(lens[x] < lens[y]) swap(x, y);
        for(int i = 19; i >= 0; --i) {
            if(lens[up[x][i]] >= lens[y]) {
                x = up[x][i];
            }
        }
        if(x == y) return x;
        for(int i = 19; i >= 0; --i) {
            if(up[x][i] != up[y][i]) {
                x = up[x][i], y = up[y][i];
            }
        }
        return up[x][0];
    }
    int query(int i, int j) {
        return dis[i] + dis[j] - 2 * dis[lca(i, j)];
    }
    void init() {
        dfs(1, 0, 0);
    }
}

namespace LCA {
    int dis[MXN], up[MXN][20], lg[MXN], DEP[MXN];
    void dfs(int u, int ba) {
        DEP[u] = DEP[ba] + 1;
        for(int i = head[u], v; ~i; i = cw[i].nex) {
            v = cw[i].v;
            if(v == ba) continue;
            dis[v] = dis[u] + cw[i].w, up[v][0] = u;
            dfs(v, u);
        }
    }
    void init() {
        for (int i = 2; i <= n; ++i) lg[i] = lg[i / 2] + 1;;
        dis[1] = 0;
        dfs(1, -1);
        for (int j = 1; j <= lg[n]; ++j)
            for (int i = 1; i <= n; ++i) up[i][j] = up[up[i][j - 1]][j - 1];
    }
    int lca(int x, int y) {
        if (DEP[x] > DEP[y]) swap(x, y);
        int k = DEP[y] - DEP[x];
        for (int i = 0; k; k = k / 2, ++i)
            if (k & 1) y = up[y][i];
        if (x == y) return x;
        k = DEP[x];
        for (int i = lg[k]; i >= 0; --i)
            if (up[x][i] != up[y][i]) x = up[x][i], y = up[y][i];
        return up[x][0];
    }
    int query(int i, int j) {
        return dis[i] + dis[j] - 2 * dis[lca(i, j)];
    }
}

namespace LCA {
    int dis[MXN], up[MXN][20], lens[MXN];
    int cnt, dfn[MXN], en[MXN], LOG[MXN];
    void dfs(int u, int ba) {
        lens[u] = lens[ba] + 1;
        dfn[++cnt] = u;
        en[u] = cnt;
        for(int i = head[u], v; ~i; i = cw[i].nex) {
            v = cw[i].v;
            if(v == ba) continue;
            dis[v] = dis[u] + cw[i].w;
            dfs(v, u);
            dfn[++ cnt] = u;
        }
    }
    inline int cmp(int u, int v) {
        return lens[u] < lens[v] ? u: v;
    }
    void init() {
        cnt = 0;
        dis[0] = lens[0] = 0;
        dfs(1, 0);
        LOG[1] = 0;
        for(int i = 2; i <= cnt; ++i) LOG[i] = LOG[i-1] + ((1<<(LOG[i-1]+1))==i);
        for(int i = 1; i <= cnt; ++i) up[i][0] = dfn[i];
        for(int j = 1; (1<<j) <= cnt; ++j)
            for(int i = 1; i + (1<<j) -1 <= cnt; ++i)
                up[i][j] = cmp(up[i][j-1], up[i+(1<<(j-1))][j-1]);
    }
    inline int lca(int x, int y) {
        int l = en[x], r = en[y];
        if(l > r) swap(l, r);
        int k = LOG[r - l + 1];
        return cmp(up[l][k], up[r-(1<<k)+1][k]);
    }
    inline int query(int i, int j) {
        return dis[i] + dis[j] - 2 * dis[lca(i, j)];
    }
}

function<void(LL,LL)> dfs = [&](LL u, LL p) {
  seg[u].first = ++step;
  for(LL i = 0; i < G[u].size(); i++) {
    LL &v = G[u][i];
    if(v == p) continue;
    dfs(v, u);
  }
  seg[u].second = step;
};
Kruskal重构树代码
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <vector>
#define fi first
#define se second
#define iis std::ios::sync_with_stdio(false)
#define pb push_back
#define o2(x) (x)*(x)
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;

const int MXN = 2e5 + 6;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
int n, m;
struct EDGE {
    int u, v, w;
}node[MXN];
int fa[MXN], Rnk[MXN], val[MXN], inde;
std::vector<int> mp[MXN];
int up[MXN][20], dep[MXN];
bool cmp(const EDGE &A, const EDGE &B) {
    return A.w < B.w;
}
int Fi(int x) {
    return fa[x]==x?x:fa[x]=Fi(fa[x]);
}
void kruskal() {
    sort(node, node + m, cmp);
    int cnt = 0; inde = n;
    for(int i = 1; i <= n; ++i) fa[i] = i, Rnk[i] = 0;
    for(int i = 0; i < m; ++i) {
        int pa = Fi(node[i].u), pb = Fi(node[i].v);
        if(pa == pb) continue;
        if(Rnk[pa] > Rnk[pb]) swap(pa, pb);
        Rnk[pb] = max(Rnk[pb], Rnk[pa] + 1);
        ++ inde;
        fa[inde] = inde; fa[pa] = inde; fa[pb] = inde;
        mp[inde].push_back(pa);
        mp[inde].push_back(pb);
        val[inde] = node[i].w;
        ++ cnt;
        if(cnt == n - 1) break;
    }
}
void dfs(int u,int ba,int d) {
    up[u][0] = ba;
    dep[u] = d;
    for(int i = 1, cf; i < 20; ++i) {
        cf = up[u][i-1];
        up[u][i] = up[cf][i-1];
    }
    int len = mp[u].size();
    for(int i = 0; i < len; ++i) {
        int v = mp[u][i];
        dfs(v, u, d+1);
    }
}
int lca(int x,int y) {
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = 19; i >= 0; --i) {
        if(dep[up[x][i]] >= dep[y]) {
            x = up[x][i];
        }
    }
    if(x == y) return x;
    for(int i = 19; i >= 0; --i) {
        if(up[x][i] != up[y][i]) {
            x = up[x][i], y = up[y][i];
        }
    }
    return up[x][0];
}
int main(){
    int Q = -3;
    while(~scanf("%d%d", &n, &m)){
        if(Q != -3) printf("\n");
        for(int i = 1; i <= 2*n+100; ++i) mp[i].clear();
        for(int i = 0; i < m; ++i) {
            scanf("%d%d%d", &node[i].u, &node[i].v, &node[i].w);
        }
        kruskal();
        dfs(inde, inde, 1);
        scanf("%d", &Q);
        while(Q --) {
            int u, v;
            scanf("%d%d", &u, &v);
            printf("%d\n", val[lca(u, v)]);
        }
    }
    return 0;
}

本题按边权从小到大排序，构建 K r u s k a l Kruskal Kruskal重构树：

写法：
在 k r u s k a l kruskal kruskal连边时，新建一个点 x x x，作为点 u u u和 v v v的父节点，并且把与 u u u和 v v v相连接的点全部转移连接到 x x x上去。为了避免再连边的过程，可以借用 k r u s k a l kruskal kruskal的并查集优化掉。

性质：
1.二叉树，叶子节点为原来的点；非叶子节点都是新加的点。
2.这棵树是以最后新建的节点为根的有根树。
3.子节点的边权小于等于父节点的边权。边权越大的节点深度越小。
4.原树上两个点路径上最大边权的最小值 是 新树上两个点 L C A LCA LCA点的点权。( l c a lca lca是两点路径上深度最小的点)
应用：
1.求两点路径上最大/小边权的最小/大值。
2.求所有从 u u u出发只经过边权不超过 x x x的边能到达的结点。
 边权按升序排序建 k u a s k a l kuaskal kuaskal重构树，找到树上深度最小的，点权不超过 x x x的结点(一般用树上倍增)
 那么它子树内的所有节点就是上述所求的。
在这里插入图片描述

若要求路径上最小边权的最大值，则改为按边权从大到小排序即可。

BZOJ3551 [ONTAK2010]Peaks加强版【Kruskal重构树+主席树+树上倍增】
[NOI2018 D1T1]归程【Kruskal重构树】

学习及应用

Cwolf9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【按秩合并并查集/LCA】UVA 11354 Bond 详解
Qiuker_jl的博客
11-17 195
题目链接：https://vjudge.net/problem/SCU-3098（UVA好像挂了，所以其实是SCU上的，这就是vjudge香的地方了） 题目大意： n个城市，通过m条道路连接，每条道路都有一个危险值，假设从城市s到城市t的一条通路为：道路a→道路b→道路c 则，这条通路的危险值被定义为道路a、b、c中危险值的最大值，现在将进行Q次询问：城市s到城市t的最小危险值为多少？ 分析： ①最小生成树包含了任意两点间权值最小的通路，所以城市s到城市t的最小危险值可以由最小生成树求得。因为要进.
UVA 11354 LCA+最小生成树
Dan__ge的博客
06-28 1670
点击打开链接 题意：给一个无向图，然后有Q次询问U V，问的是U到V的所有路径中的最小值最大 思路：U到V的路径最小值最大，则这条边肯定是最小生成树上的边，那么我们可以先将所有的最小生成树上的边全都找出来，然后现在是一个树，然后跑一边LCA，对于现在询问的U到V，只要找到它们的最近公共祖先，然后两个点向上找到它，比较路径中的最大值即可  PS:这么暴力找跑得有点慢#include #incl
最小生成树+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
UVA-11354
常胜将军的博客
05-31 379
题意：最小瓶颈路，给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。 思路一：并查集（按秩合并），求一个最小生成树， 任意两点在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 但是n和q都太大， 如果直接顺着树走，每次询问最大复杂度O(n)， 那么复杂度高达O(n^2)，会超时。 并查集在用了路径压缩之后效...
UVA 11354 Bond
P.H.S
10-16 250
UVA 11354 Bond最小生成树，LCA，ST题目给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。思路首先，我们可以发现，如果求一个最小生成树， 那么任意两点， 在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 然后在最小生成树上做路径最小值的询问，处理出LCA，在用RMQ。代码#include<b
LCA.zip_lca Tarjan pascal_lca pascal_tarjan lca pascal
09-14
在IT领域，特别是数据结构和算法分析中，"LCA"是"Lowest Common Ancestor"（最近公共祖先）的缩写，这是一个经典的问题，常常出现在树形结构的处理中。给定一个树形结构和若干对节点，我们需要找出这些节点的最近...
lca_one_layer.zip_LCA_LCA算法_图像分析_图像基元_基元 matlab
07-13
LCA (Lobe Component Analysis) Lobe成分分析法，图像基元的特征检测算法。
LCA.rar_LCA_visual c
09-19
《最小公共祖先算法（LCA）在Visual C++中的实现》 最小公共祖先（Lowest Common Ancestor，简称LCA）算法是图论和数据结构领域中的一个重要问题，特别是在树形结构的处理中有着广泛的应用。例如，在计算机科学中，...
lca_Windows_6.9_DEV.30_predev_LCA.exe
09-01
数据泄密（泄露）防护...数据泄密防护(DLP)是通过一定的技术手段，防止企业的指定数据或信息资产以违反安全策略规定的形式流出企业的一种策略。DLP这一概念来源于国外，是目前国际上最主流的信息安全和数据防护手段
St表欧拉序倍增搞LCA.zip_LCA_lca st表_st表
09-25
在查询LCA时，可以先通过St表找出两个节点在欧拉序中的最近祖先节点，再通过倍增算法快速找到这两个节点的LCA。这样的组合使用能够提供O(log^2 n)的查询复杂度，虽然不如其他特定的LCA算法（如Mo's算法或Sparse ...
poj 1330 Nearest Common Ancestors 朴素LCA算法
kongming_acm的专栏
07-08 732
Nearest Common AncestorsTime Limit: 1000MS Memory Limit: 10000KTotal Submissions: 9213 Accepted: 4883DescriptionA rooted tree is a well-know
UVA 11354 - Bond（并查集-按秩合并）
AC_Arthur的专栏
02-15 3517
题目链接：点击打开链接 题意：给出一张n个点m条边的无向图， 每条边有一个危险度，有q个询问， 每次给出两个点s、t，找一条路， 使得路径上的最大危险度最小。 思路：首先，我们可以发现，如果求一个最小生成树， 那么任意两点， 在生成树上有唯一路径， 而且这条路径上的最大危险值一定最小。 但是n和q都太大， 如果直接顺着树走，每次询问最大复杂度O(n)， 那么复杂度高达O(n^2)，会超时。  
uva11354 - Bond 最小瓶颈路+LCA
09-26 607
Once again, James Bond is on his way tosaving the world. Bond's latest mission requires him to travel between severalpairs of cities in a certain country.   The country has N cities(numbered by 1, 2
POJ 1470 Tarjan算法
weixin_33686714的博客
04-10 132
裸的LCA,读入小坑。Tarjan算法大坑，一开始不知道哪儿错了，后来才发现，是vis数组忘了清零了(⊙﹏⊙)b 傻傻的用了邻接矩阵。。。很慢啊，1100多ms。 Closest Common Ancestors Description Write a program that takes as input a rooted tree and a list of pai...
LCA 最裸版
Dikea's Blog
06-10 548
#include using namespace std; #define maxn 100000 + 10 struct Edge { int v; int next; } e[maxn<<1]; int head[maxn], cnt; void adde(int u, int v) //单向边 { e[cnt].v = v; e[cnt].next
loj136 (最小瓶颈路,多次询问)
weixin_30663391的博客
10-17 215
题目描述 给定一个包含n nn个节点和m mm条边的图，每条边有一个权值。你的任务是回答k kk个询问，每个询问包含两个正整数s ss和t tt表示起点和终点，要求寻找从s ss到t tt的一条路径，使得路径上权值最大的一条边权值最小。 输入格式 第一行包含三个整数n nn、m...
CodeForces - 1304E H - 1-Trees and Queries （LCA）
yhb的博客
02-17 278
Gildong was hiking a mountain, walking by millions of trees. Inspired by them, he suddenly came up with an interesting idea for trees in data structures:What if we add another edge in a tree? Then h...
训练指南 UVA - 11354（最小生成树 + 倍增LCA）
weixin_30538029的博客
02-02 93
layout: post title: 训练指南 UVA - 11354（最小生成树 + 倍增LCA） author: "luowentaoaa" catalog: true mathjax: true tags: - 最小生成树 - LCA - 图论 - 训练指南 Bond UVA - 11354 题意 给你一张无向图，然后有若干组询问，让你输出a->b的最小瓶颈路 题解 先求出最小生...
LCA裸题 Distance in the Tree URAL - 1471
qq_29904713的博客
04-14 237
A weighted tree is given. You must find the distance between two given nodes. Input The first line contains the number of nodes of the tree n (1 ≤ n ≤ 50000). The nodes are numbered from 0 to n–1....
simapro学习_(完整版)LCA;;两种软件比较
最新发布
06-09
Simapro 是一款功能强大的生命周期评价（LCA）软件，它可以评价任何产品或过程在其整个生命周期中对环境的影响，并提供了丰富的功能和工具来帮助用户进行准确的评估。下面是关于 Simapro 学习和与其他 LCA 软件的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值