【洛谷P4234】最小差值生成树

news/2024/11/21 1:36:00/

Description

给定一张n个点,m条边的无向图,求出边权最大值和最小值差值最小的生成树

Solution

LCT+并查集

按照最小生成树的思路,先将边按照边权从小到大排序,然后顺序考虑每一条边

如果当前这条边的两个端点没有连通,那么直接连通

如果两个端点已经连通,我们加上这条边会形成一个环,那么为了让“边权最大值和最小值差值”尽可能小,我们可以将这个环上最短的一条边删掉,换成这条边(显然是对的)

维护最小值可以通过LCT实现,连边、短边也是LCT的基本操作

当目前的边已经是一棵树的时候更新答案即可完成

Code

  1 #include <bits/stdc++.h>
  2 using namespace std;
  3 typedef long long ll;
  4 const int N = 50010;
  5 const int M = 200010;
  6 inline int read() {
  7     int ret = 0, op = 1;
  8     char c = getchar();
  9     while (!isdigit(c)) {
 10         if (c == '-') op = -1; 
 11         c = getchar();
 12     }
 13     while (isdigit(c)) {
 14         ret = (ret << 3) + (ret << 1) + c - '0';
 15         c = getchar();
 16     }
 17     return ret * op;
 18 }
 19 struct Edge {
 20     int from, to, dis;
 21     bool operator <(const Edge &x) const {
 22         return dis < x.dis;
 23     }
 24 } edge[M];
 25 struct LCT {
 26     int fa, val, minn, ch[2], tag;
 27 } a[N + M];
 28 int n, m, s[N + M], f[N];
 29 int vis[M];
 30 int find(int x) {
 31     if (f[x] != x) return f[x] = find(f[x]);
 32     return f[x];
 33 }
 34 inline int isnroot(int now) {
 35     return a[a[now].fa].ch[0] == now || a[a[now].fa].ch[1] == now;
 36 }
 37 inline int get(int x, int y) {
 38     return a[x].val < a[y].val ? x : y;
 39 }
 40 inline void update(int now) {
 41     int l = a[now].ch[0];
 42     int r = a[now].ch[1];
 43     a[now].minn = get(now, get(a[l].minn, a[r].minn));
 44 } 
 45 inline void rev(int now) {
 46     swap(a[now].ch[0], a[now].ch[1]);
 47     a[now].tag ^= 1;
 48 }
 49 inline void pushdown(int now) {
 50     if (a[now].tag) {
 51         if (a[now].ch[0]) rev(a[now].ch[0]);
 52         if (a[now].ch[1]) rev(a[now].ch[1]);
 53         a[now].tag = 0;
 54     }
 55 }
 56 void rotate(int x) {
 57     int y = a[x].fa;
 58     int z = a[y].fa;
 59     int xson = a[y].ch[1] == x;
 60     int yson = a[z].ch[1] == y;
 61     int B = a[x].ch[xson ^ 1];
 62     if (isnroot(y)) a[z].ch[yson] = x;
 63     a[x].ch[xson ^ 1] = y;
 64     a[y].ch[xson] = B;
 65     if (B) a[B].fa = y;
 66     a[y].fa = x;
 67     a[x].fa = z;
 68     update(y);
 69 }
 70 void splay(int x) {
 71     int y = x, z = 0;
 72     s[++z] = y;
 73     while (isnroot(y)) y = a[y].fa, s[++z] = y;
 74     while (z) pushdown(s[z--]);
 75     while (isnroot(x)) {
 76         y = a[x].fa;
 77         z = a[y].fa;
 78         if (isnroot(y))
 79             (a[z].ch[0] == y) ^ (a[y].ch[0] == x) ? rotate(x) : rotate(y);
 80         rotate(x);
 81     }
 82     update(x);
 83 }
 84 void access(int x) {
 85     for (register int y = 0; x; y = x, x = a[x].fa) {
 86         splay(x); a[x].ch[1] = y; update(x);
 87     }
 88 }
 89 void makeroot(int x) {
 90     access(x);
 91     splay(x);
 92     rev(x);
 93 }
 94 void link(int i) {
 95     makeroot(edge[i].from);
 96     a[edge[i].from].fa = i + N;
 97     a[i + N].fa = edge[i].to;
 98 }
 99 void cut(int i) {
100     access(edge[i - N].from);
101     splay(i);
102     a[a[i].ch[1]].fa = a[a[i].ch[0]].fa = 0;
103     a[i].ch[0] = a[i].ch[1] = 0;
104 }
105 int main() {
106     n = read(); m = read();
107     for (register int i = 0; i <= n; ++i) f[i] = i, a[i].val = 2147483647;
108     for (register int i = 1; i <= m; ++i) {
109         edge[i].from = read(); edge[i].to = read(); edge[i].dis = read();
110     }
111     sort(edge + 1, edge + m + 1);
112     int sum = 0, ans = 0, k = 1;
113     for (register int i = 1; i <= m; ++i) {
114         a[i + N].val = edge[i].dis;
115         int x = edge[i].from;
116         int y = edge[i].to;
117         if (find(x) != find(y)) {
118             vis[i] = 1;
119             sum++;
120             link(i);
121             f[f[x]] = f[y];
122             if (sum == n - 1) ans = edge[i].dis - edge[k].dis;
123         }
124         else {
125             if (x == y) continue ;
126             vis[i] = 1;
127             makeroot(x);
128             access(y); splay(y);
129             vis[a[y].minn - N] = 0;
130             while (vis[k] == 0) ++k;
131             cut(a[y].minn); link(i);
132             if (sum == n - 1) ans = min(ans, edge[i].dis - edge[k].dis);
133         }
134     }
135     printf("%d\n", ans);
136     return 0;
137 }
AC Code

 

转载于:https://www.cnblogs.com/shl-blog/p/11354557.html


http://www.ppmy.cn/news/356265.html

相关文章

luogu 4234 最小差值生成树 LCT

感觉码力严重下降~ #include <bits/stdc.h> #define N 400006 #define inf 1000000000 #define setIO(s) freopen(s".in","r",stdin) using namespace std; multiset<int>S; multiset<int>::iterator it; struct…

洛谷P4234 最小差值生成树

LCT维护生成树 把边从小到大排序&#xff0c;然后一条一条加边&#xff0c;如果成环就把环上最小的删了&#xff0c;我们得到的第一个生成树就是最小生成树。 然后之后每一条边都比前面的生成树的最大边大&#xff0c;我们用这条边的权值减去生成树里最小的&#xff0c;更新答案…

洛谷 P4234 LCT + 排序 + 枚举

求边权最大值与最小值的差值最小的生成树&#xff0c;输出这个差值大小。 按权值排序&#xff0c;我们等同于枚举最大值&#xff0c;然后更新生成树让生成树的最小值尽可能最大。 也就是每次加入边&#xff0c;若构成环&#xff0c;则去掉环上最小值。 若加入边不会构成环&…

LuoguP4234_最小差值生成树_LCT

LuoguP4234_最小差值生成树_LCT 题意&#xff1a; 给出一个无向图&#xff0c;求最大的边权减最小的边权最小的一棵生成树。 分析&#xff1a; 可以把边权从大到小排序&#xff0c;然后类似魔法森林那样插入。 如果两点不连通&#xff0c;直接连上&#xff0c;否则找到两点间最…

NKOJ 4234 三角分形

问题描述 今天何老板得到了一个神奇的正三角形&#xff0c;它具有自动分形技能。 一天后&#xff0c;它会分成4个相同的正三角形&#xff0c;其中三个“尖尖”朝上&#xff0c;一个“尖尖”朝下。 一天后&#xff0c;里面的每个三角形又会按上述规则分形下去。 如此反复………

[luogu4234]最小差值生成树

[luogu4234]最小差值生成树 luogu 从小到大枚举边,并连接,如果已连通就删掉路径上最小边 lct维护\(ansmin(E_{max}-E_{min})\) #include<bits/stdc.h> using namespace std; const int _4e55; int re(){int x0,w1;char chgetchar();while(ch<0||ch>9){if(ch-)w-1;c…

HDU 4234 Moving Points

刚开始做的时候还以为是暴搜&#xff0c;YY了各种剪枝&#xff0c;结果华丽丽的TLE了 正解&#xff1a; 状态压缩DP dp[当前走到的点][状态] 状态&#xff1a; 第i位表示第i个点有没有被消灭 转移&#xff1a; 详见代码 注意&#xff1a; 计算转移cost时要用O(1) 的算法 二分…

4234最小差值生成树

有点巧妙啊&#xff01; s[x]每次维护的是最小值 我们将边按从大到小排个序,这样编号小的就在前面啦&#xff01;QAQ 再按最小生成树的LCT的做法来 不过我们每次要用一个book标记前面最小边的编号 每次要更新答案时&#xff0c;一直往前跳&#xff0c;跳到最晚更新的即使最小的…