最小树形图

最新推荐文章于 2022-03-06 15:21:12 发布
最新推荐文章于 2022-03-06 15:21:12 发布
阅读量302 收藏 3
点赞数 1
分类专栏： ACM--图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/113910655
版权

文章目录

最小树形图

1.算法分析

有向图上的最小生成树（Directed Minimum Spanning Tree）称为最小树形图。常用的算法是朱刘算法（也称 Edmonds 算法），可以在 O ( n m ) O(nm) O(nm) 时间内解决最小树形图问题。

该算法最后能够找到一个从根出发，能够走到任意一个点的一个最小权值的有向的树。

流程

  1. 对于每个点，选择它入度最小的那条边
  2. 如果没有环，算法终止；否则进行缩环并更新其他点到环的距离。
  3. 缩点时：对于环内部的边，删去；对于终点在环内的，边权变为w外-w环内。

2.模板

#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 100 + 5;
const int mod = 1000000000 + 7;
const double eps = 1e-8;
typedef pair<int, int> PII;
int id[N], vis[N], pre[N], pos;  // id记录每个点属于哪个环，vis用来判断几个点是否处于一个环内，
                                 // pre记录每个点的前一个节点，pos记录虚节点
double dis[N], INF = 1e17;  // dis记录每个点到最小生成树的距离
PII point[N];
// 定义边的结构
struct node {
    int u, v;
    double cost;
} edge[N * N];
int n, m;
// 朱刘算法
// root:根节点(记得下标从0开始)
// V点数0~V-1
// E边数0~E-1
double zhuliu(int root, int V, int E) {
    double sum = 0;  // 计算当前最小树形图的边权值和
    while (true) {
        // 把每个点到最小生成树的距离置为无穷
        for (int i = 0; i < V; i++) {
            dis[i] = INF;
        }

        //找最小入边
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            if (u != v && dis[v] > edge[i].cost) {
                dis[v] = edge[i].cost;
                pre[v] = u;
                if (u == root) {
                    pos = i;
                }
            }
        }

        //某点不存在入边，算法结束
        for (int i = 0; i < V; i++) {
            if (dis[i] == INF && i != root) return -1;
        }
        int cnt = 0;  // 记录当前这张图内点的个数
        memset(id, -1, sizeof id);
        memset(vis, -1, sizeof vis);
        dis[root] = 0;  // 把根节点放入最小树形图

        //找环
        for (int i = 0; i < V; i++) {
            int v = i;
            sum += dis[i];
            while (id[v] == -1 && vis[v] != i && v != root) {
                vis[v] = i;
                v = pre[v];
            }

            //找到环的时候缩点编号
            if (id[v] == -1 && v != root) {
                for (int u = pre[v]; u != v; u = pre[u]) {
                    id[u] = cnt;  // 把u点放入编号为cnt的环内
                }
                id[v] = cnt++;
            }
        }

        //如果没有环，则以找到最小树形图，算法结束
        if (!cnt) break;

        //把余下的不在环里的点编号
        for (int i = 0; i < V; i++) {
            if (id[i] == -1) id[i] = cnt++;
        }

        //更新距离
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            edge[i].u = id[u];
            edge[i].v = id[v];
            if (id[u] != id[v]) edge[i].cost -= dis[v];
        }
        V = cnt;          // 新图的点数为cnt
        root = id[root];  // 新图的根为原来的根所在的缩点集
    }
    return sum;
}

double get_dist(int x, int y) {
    return sqrt(((double)point[x].first - point[y].first) * ((double)point[x].first - point[y].first) + ((double)point[x].second - point[y].second) * ((double)point[x].second - point[y].second) );
}

int main() {
    while(scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= n; ++i) cin >> point[i].first >> point[i].second;
        for (int i = 0; i < m; ++i) {
            int a, b;
            cin >> a >> b;
            edge[i] = {a - 1, b - 1, get_dist(a, b)};
        }
        double t = zhuliu(0, n, m);
        if (t == -1) cout << "poor snoopy\n";
        else printf("%.2lf\n", t);
    }
    return 0;
}

3.典型例题

3.1 定根最小树形图

acwing2417. 指挥网络

题意： 给定一张n个点m条边的有向图，边的权值为double型，要求找到这张图的最小树形图。 1 < = N < = 100 , 1 < = M < = 1 0 4 , 0 < x i , y i < = 10000 , 1 < = a , b < = N , a ≠ b 1<=N<=100, 1<=M<=10^4,0<xi,yi<=10000,1<=a,b<=N, a \neq b 1<=N<=100,1<=M<=104,0<xi,yi<=10000,1<=a,b<=N,a​=b

题解： 模板题

代码：

#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 100 + 5;
const int mod = 1000000000 + 7;
const double eps = 1e-8;
typedef pair<int, int> PII;
int id[N], vis[N], pre[N], pos;  // id记录每个点属于哪个环，vis用来判断几个点是否处于一个环内，
                                 // pre记录每个点的前一个节点，pos记录虚节点
double dis[N], INF = 1e17;  // dis记录每个点到最小生成树的距离
PII point[N];
// 定义边的结构
struct node {
    int u, v;
    double cost;
} edge[N * N];
int n, m;
// 朱刘算法
// root:根节点(记得下标从0开始)
// V点数0~V-1
// E边数0~E-1
double zhuliu(int root, int V, int E) {
    double sum = 0;  // 计算当前最小树形图的边权值和
    while (true) {
        // 把每个点到最小生成树的距离置为无穷
        for (int i = 0; i < V; i++) {
            dis[i] = INF;
        }

        //找最小入边
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            if (u != v && dis[v] > edge[i].cost) {
                dis[v] = edge[i].cost;
                pre[v] = u;
                if (u == root) {
                    pos = i;
                }
            }
        }

        //某点不存在入边，算法结束
        for (int i = 0; i < V; i++) {
            if (dis[i] == INF && i != root) return -1;
        }
        int cnt = 0;  // 记录当前这张图内点的个数
        memset(id, -1, sizeof id);
        memset(vis, -1, sizeof vis);
        dis[root] = 0;  // 把根节点放入最小树形图

        //找环
        for (int i = 0; i < V; i++) {
            int v = i;
            sum += dis[i];
            while (id[v] == -1 && vis[v] != i && v != root) {
                vis[v] = i;
                v = pre[v];
            }

            //找到环的时候缩点编号
            if (id[v] == -1 && v != root) {
                for (int u = pre[v]; u != v; u = pre[u]) {
                    id[u] = cnt;  // 把u点放入编号为cnt的环内
                }
                id[v] = cnt++;
            }
        }

        //如果没有环，则以找到最小树形图，算法结束
        if (!cnt) break;

        //把余下的不在环里的点编号
        for (int i = 0; i < V; i++) {
            if (id[i] == -1) id[i] = cnt++;
        }

        //更新距离
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            edge[i].u = id[u];
            edge[i].v = id[v];
            if (id[u] != id[v]) edge[i].cost -= dis[v];
        }
        V = cnt;          // 新图的点数为cnt
        root = id[root];  // 新图的根为原来的根所在的缩点集
    }
    return sum;
}

double get_dist(int x, int y) {
    return sqrt(((double)point[x].first - point[y].first) * ((double)point[x].first - point[y].first) + ((double)point[x].second - point[y].second) * ((double)point[x].second - point[y].second) );
}

int main() {
    while(scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= n; ++i) cin >> point[i].first >> point[i].second;  // 读入点
        for (int i = 0; i < m; ++i) {
            int a, b;
            cin >> a >> b;
            edge[i] = {a - 1, b - 1, get_dist(a, b)};  // 读入边
        }
        double t = zhuliu(0, n, m);  // 朱刘算法
        if (t == -1) cout << "poor snoopy\n";  // 无解
        else printf("%.2lf\n", t);  // 最小树形图的最小权值
    }
    return 0;
}

3.2 不定根最小树形图

hdu2121 Ice_cream’s world II

题意： 有n个城市，问能否在者n个城市中选一个城市作为首都，要求首都都能到其他城市，道路花费要最少，且道路都是单向的。打印最少花费和选出来的首都。

题解： 本题要找一个根，同时要求出最小树形图的权值和。可以虚拟一个虚根，如果以虚根为根生成的最小树形图权值和ans减去不包含虚根的全部权值和sum为大于全部权值和，那么不存在这样一个虚根（因为最多只会有一条虚边）；反之，存在，则真正的最小树形图的权值和为 ans - sum,根节点为与虚根相连的那个点pos - m(n节点对应m边，n+1节点对应m+1边)

代码：

#include <stdio.h>
#include <cstdlib>
#include <cstring>
#include <iostream>
#define LL long long
using namespace std;
const int N = 1000 + 5;
const int mod = 1000000000 + 7;
const double eps = 1e-8;
int id[N], vis[N], pre[N],
    pos;  // id记录每个点属于哪个环，vis用来判断几个点是否处于一个环内，
          // pre记录每个点的前一个节点，pos记录虚节点
LL dis[N], INF = 1e17;  // dis记录每个点到最小生成树的距离
// 定义边的结构
struct node {
    int u, v, cost;
} edge[N * N];

// 朱刘算法
// root:根节点
// V点数0~V-1
// E边数0~E-1
LL zhuliu(int root, int V, int E) {
    LL sum = 0;  // 计算当前最小树形图的边权值和
    while (true) {
        // 把每个点到最小生成树的距离置为无穷
        for (int i = 0; i < V; i++) {
            dis[i] = INF;
        }

        //找最小入边
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            if (u != v && dis[v] > edge[i].cost) {
                dis[v] = edge[i].cost;
                pre[v] = u;
                if (u == root) {
                    pos = i;
                }
            }
        }

        //某点不存在入边，算法结束
        for (int i = 0; i < V; i++) {
            if (dis[i] == INF && i != root) return -1;
        }
        int cnt = 0;  // 记录当前这张图内点的个数
        memset(id, -1, sizeof id);
        memset(vis, -1, sizeof vis);
        dis[root] = 0;  // 把根节点放入最小树形图

        //找环
        for (int i = 0; i < V; i++) {
            int v = i;
            sum += dis[i];
            while (id[v] == -1 && vis[v] != i && v != root) {
                vis[v] = i;
                v = pre[v];
            }

            //找到环的时候缩点编号
            if (id[v] == -1 && v != root) {
                for (int u = pre[v]; u != v; u = pre[u]) {
                    id[u] = cnt;  // 把u点放入编号为cnt的环内
                }
                id[v] = cnt++;
            }
        }

        //如果没有环，则以找到最小树形图，算法结束
        if (!cnt) break;

        //把余下的不在环里的点编号
        for (int i = 0; i < V; i++) {
            if (id[i] == -1) id[i] = cnt++;
        }

        //更新距离
        for (int i = 0; i < E; i++) {
            int u = edge[i].u, v = edge[i].v;
            edge[i].u = id[u];
            edge[i].v = id[v];
            if (id[u] != id[v]) edge[i].cost -= dis[v];
        }
        V = cnt;          // 新图的点数为cnt
        root = id[root];  // 新图的根为原来的根所在的缩点集
    }
    return sum;
}

int main() {
    int n, m;
    LL ans, temp;
    while (~scanf("%d%d", &n, &m)) {
        temp = 1;

        // 读入边的信息
        for (int i = 0; i < m; i++) {
            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);
            temp += edge[i].cost;
        }

        //以n为虚拟节点
        for (int i = m; i < n + m; i++) {
            edge[i].u = n;
            edge[i].v = i - m;
            edge[i].cost = temp;
        }

        //  得到以虚节点为根节点的最小树形图的边权值和
        ans = zhuliu(n, n + 1, n + m);
        if (ans == -1 || ans - temp >= temp)
            puts("impossible\n");
        else
            printf("%lld %d\n\n", ans - temp, pos - m);
    }
    return 0;
}
「已注销」
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小树形图 Tarjan的DMST算法
q779的博客
03-27 2098
这篇是Tarjan的DMST算法哦！ qwq
最小树形图（有向图的最小生成树）
热门推荐
辰巳X4
08-09 1万+
我们知道，无向图的最小生成树的求法有Krusal和prime算法，一个是归点一个是归边，在具体实现上Krusal可以用并查集实现，难度不大。 这里稍微区别一下最短路径和最小生成树（因为我又搞混了23333） 最小生成树能够保证首先是树（对于n个顶点的图只有n-1条边），其次保证任意两个顶点之间都可达，再次保证这棵树的边权值之和为最小，但不能保证任意两点之间是最短路径； 最短路径保证从源点S到目地...
最小树形图-朱刘算法详解 +例题解析
pursuit的博客
08-17 5464
文章目录最小树形图定义和最小生成树的区别朱刘算法思想步骤流程展示算法实现例题 最小树形图 定义 对于有向图G=(V,E)G = (V,E)G=(V,E)，其中具有如下性质 GGG中不包含有向环。 存在一个根结点uuu，它不是任何弧的终点，而且uuu的其他顶点都恰好是唯一的一条弧的终点。 那么则称GGG是以uuu为根的树形图。 更笼统的讲，实际上就是有一颗不存在有向环的有向树，且除根结点uuu外的每个顶点都只有一条入边。 而最小树形图则是权值最小的那个。 这是一个最小树形图的例子。 和最小生成树的区别
最小树形图（朱-刘算法）
Izayoi_w的博客
08-13 741
概念导入：最小树形图可以简单的理解为树枝有方向的最小生成树，加上了方向的限制，使得得到它要稍微麻烦一点，解决这个问题的算法是朱永津与刘振宏在上世纪60年代提出的朱-刘算法（难得的中国人的算法）。 定义：设G = (V,E)是一个有向图，它具有下述性质： 1. G中不包含有向环；　 2. 存在一个顶点vi，它不是任何弧的终点，而V中的其它顶点都恰好是唯一的一条弧的终点； 则...
【算法精讲】最小树形图 (两份讲解 配套例题)
Suprit's blog
06-14 1554
其一 概述 最小树形图, 简而言之就是求有向带权图的最小生成树. 官方定义是这样的: 最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振宏提出的复杂度为O(VE)的算法：朱、刘算法。 今天我们就来浅谈一下最小树形图的问题。 最小树形图, 简而言之就是求有向带权图的最小生成树....
最小树形图_树形图权_最小树形图虚根_
10-02
输出一个图中最佳源点的最小树形图权值和的一个程序
zuixiaoshuxingtu.rar_最小树形图
09-22
输出最小树形图路径，支持读文本，只需要填写相应文本，指定相应路径即可
最小树形图.pptx
07-14
判断是否存在树形图的方法很简单，只需要以v为根作一次图的遍历就可以了，所以下面的算法中不再考虑树形图不存在的情况。 在所有操作开始之前，我们需要把图中所有的自环全都清除。很明显，自环是不可能在任何一个树...
最小树形图模板朱刘算法分享
09-04
主要介绍了最小树形图模板朱刘算法，有需要的朋友可以参考一下
最小树与最小树形图
06-11
它是关于最小树与最小树形图 方面的相关资料。。。
最小树形图/朱刘算法
qq_52406324的博客
03-06 308
最小树形图/朱刘算法 最小生成树是具有最小权值的无向树，最小树形图则是具有最小权值的有向树 算法思想和kruskal类似，也是采用贪心的思想，每次取用权值最小的那条边，只是由于有向图边权带有方向，有一些特殊情况需要我们去解决。 1.是否存在最小树形图；我们知道在无向图中（不考虑负权），只要所有点都是连通的，就一定存在最小生成树，在有向图中也是一样的，每个点都必须存在一条连向它的边，即不存在某个点，它的入度为0 ，如果有某个点入度为0，那就不存在树形图(不连通)，更不存在最小树形图。 2.每次取权值最小的边，
最小树形图（朱刘算法）
Z7784562的博客
05-17 448
思路： 最小树形图就是在有向图中，以一个点为根的有向生成树，并且边权值和最小。 思路大体上是贪心。 1、贪心地选取每个点最小的入边。 2、存在环则缩点，将其余边权值减去这个边终点的最小入边值。因为这相当于删除这个边的原来入边，再加上另外一条边。 3、重复1，2直到无环。 复杂度为O(NM)O(NM)O(NM)。Tarjan更快的算法还不会。 代码： #include<bits/stdc++.h> #define pii pair<int,int> #define ll long lo
图论 —— 生成树 —— 最小树形图
Alex_McAvoy的博客
01-05 5610
【概述】 最小树形图，就是给出一个带权有向图，从中指定一个特殊的结点 root，求一棵以 root 为根的有向生成树 T，且使得 T 中所有边权值最小。 简单来说，最小树形图就是有向图的最小生成树。 【朱刘算法】 1.过程 简单来说，朱刘算法分为四个过程： 1）求最短弧集合 E 2）判断集合 E 中有没有有向环，如果有转步骤 3，否则转 4 3）收缩点，把有向环收缩成一个点，并且对...
最小树形图 之 朱刘算法【模板】
世界很大
08-26 4355
定义：一个有向图，存在从某个点为根的，可以到达所有点的一个最小生成树，则它就是最小树形图。 朱刘算法实现过程： 【在选出入边集后（看步骤1），若有向图中不存在有向环，说明该图就是最小树形图】 1，选入边集——找到除root点之外，每一个点的所有入边中权值最小的，用数组in[]记录下这个最小权值，用pre[]记录到达该点的前驱；（若图中存在独立点，最小树形图是不存在的，所
最小树形图入门总结
_marcel的博客
06-03 2689
求解最小树形图最小权值一般使用算法为朱刘算法. 原理入门推荐博客:https://blog.csdn.net/qq_34731703/article/details/53965684 ps:该博客使用模板为邻接矩阵实现,便于理解,但是在做题时邻接矩阵初始化耗时太多,我们需要改成前向星的存储方式. 关于模板: 用前向星实现的朱刘算法网上有许多模板,这里放个我觉得比较优秀的模板:https://...
图的最小生成树是什么数据结构？
最新发布
06-06
图的最小生成树是一种树形结构，它是由一个连通无向图中的所有顶点和一部分边构成的树，该树包含了原图中所有顶点，但只包含原图中的一部分边，使得树的边权值之和最小。 通常使用两种数据结构来存储和表示图的最小...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值