有向图的最小树形图
最小树与最小树形图(数学建模资料)
考虑弧（i，j）时，只需判断first(i)与 first(j)是否相 等,相等则端点属于同一单向链表；否则合并链表. 因此所有这些判断所需要的计算时间为O(m).
合并时, 我们总是把节点数较多的链表L’ 放在前面, 而把节点 数较少的链表L追加在后面.
16
Kruskal 算法的计算复杂性
合并后, 对于size和last的修改非常容易,可以在常数时间内完成; 但对 first的 修改必须对链表L中的每个元素(节点)进行, 复杂度为 O(h)，h=size(L) . 这种合并最多进行(n-1)次, 对 first 进行修改的总的复杂度为 O(n log n) 记链表L追加在链表L’（size( L) h, size( L ) h , h h ) 后面而合并 成一个链表时的计算时间（操作次数）不超过 p1h（这里p1为常数）
R1
C13 C12
C24
R3
R2
R4
一般地，给定差异信息cij，如何确定存贮哪些行之间的差异元素, 使得存 贮空间尽可能少呢？这一问题可以用最小树问题来描述: 我们把矩阵每行 作为一个节点构成一个完全图, 第i个节点对应于矩阵第i行，并令弧(i,j) 上的权为cij. 对于存贮问题, 实际上只需要存贮一行的元素, 以及由该完 全图的一棵支撑树所对应的差异元素. 最小树就对应于最优的存贮方案.
O(m log n mn) O(mn)
O(n3 )
15
Kruskal 算法的计算复杂性改进
算法实现改进：利用三个数组
size - 用来记录每个链表中所含节点的个数(链表规模)； last - 用来记录每个链表中最后的节点编号 first - 用来记录每个节点所在链表的第一个节点. 如果链表L={1，2，4，5} ，则size(L)=|L|=4, last(L)=5, first(1)= first(2)= first(4) = first(5)=1.
最小树形图——朱刘算法学习笔记
最⼩树形图——朱刘算法学习笔记问题描述给定⼀张⽆向图和⼀个根r，求出⼀个n-1条边的⼀张⼦图，使得从r出发可以到达任意⼀个点，同时使得所有选择的边权之和最⼩。
根据最⼩树形图的定义，这张图的除了根的每⼀个点都必须有且仅有⼀个⼊度。
那么我们可以贪⼼⼀点，对于除了根的所有点都找出⼀条连向它的边且边权最⼩，称作这个点的代表边，并把这些边权加⼊答案中。
然后我们找出了⼀张图，这张图中每个点都只有⼀个⼊度。
如果不算根的话，它应当是⼀个外向基环树森林。
然后我们找到所有的环，把它们缩成⼀个点。
再去扫描不在环内的边，假设有u->v,那么这条边的边权要减掉v的代表边权。
因为v是⼀个环，如果继续连u->v的边的话，相当于是把原来v的⽗亲断开，再连上u。
于是我们就完成了缩点，⼀直做下去，知道图中没有环。
⽆解就是图中除了根有点没有⼊度。
代码细节1、初始化，我们令id[]表⽰这个点在那个环⾥，top[]表⽰环顶(找环时⽤)，mi[]表⽰代表边的边权,cnt表⽰环数。
2、找环的时候，因为是⼀颗外向基环树，所以我们对于每个点记录father，这样father就变成了内向基环树，这样可以⽅便找环。
3、没有和其他点组成环的让它⾃⼰成为⼀个环。
4、每做完⼀轮之后要更新⼀下点数和根。
代码#include<iostream>#include<cstdio>#define N 109#define M 10009#define inf 2e9using namespace std;int tot,top[N],id[N],cnt,mi[N],n,m,fa[N],r;long long ans;inline int rd(){int x=0;char c=getchar();bool f=0;while(!isdigit(c)){if(c=='-')f=1;c=getchar();}while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}return f?-x:x;}struct edge{int from,to,l;}e[M];inline void add(int u,int v,int l){e[++tot].to=v;e[tot].l=l;e[tot].from=u;}inline bool solve(){while(1){for(int i=1;i<=n;++i)id[i]=top[i]=0,mi[i]=inf;for(int i=1;i<=m;++i)if(e[i].to!=e[i].from&&e[i].l<mi[e[i].to])fa[e[i].to]=e[i].from,mi[e[i].to]=e[i].l;int u=0;mi[r]=0;for(int i=1;i<=n;++i){if(mi[i]==inf)return0;ans+=mi[i];for(u=i;u!=r&&top[u]!=i&&!id[u];u=fa[u])top[u]=i;if(u!=r&&!id[u]){id[u]=++cnt;for(int v=fa[u];v!=u;v=fa[v])id[v]=cnt;}}if(!cnt)return1;for(int i=1;i<=n;++i)if(!id[i])id[i]=++cnt;for(int i=1;i<=m;++i){int num=mi[e[i].to];e[i].from=id[e[i].from];e[i].to=id[e[i].to];if(e[i].from!=e[i].to)e[i].l-=num;}n=cnt;r=id[r];cnt=0;}}int main(){n=rd();m=rd();r=rd();int u,v,w;for(int i=1;i<=m;++i){u=rd();v=rd();w=rd();add(u,v,w); }if(solve())cout<<ans;else puts("-1");return0;}。
ACM算法模板(吉林大学)
目录目录 (1)Graph 图论 (3)|DAG的深度优先搜索标记 (3)|无向图找桥 (3)|无向图连通度(割) (3)|最大团问题DP+DFS (3)|欧拉路径O(E) (3)|D IJKSTRA数组实现O（N^2） (3)|D IJKSTRA O(E* LOG E) (4)|B ELLMAN F ORD单源最短路O(VE) (4)|SPFA(S HORTEST P ATH F ASTER A LGORITHM) (4)|第K短路（D IJKSTRA） (5)|第K短路（A*） (5)|P RIM求MST (6)|次小生成树O(V^2) (6)|最小生成森林问题(K颗树)O(MLOGM) (6)|有向图最小树形图 (6)|M INIMAL S TEINER T REE (6)|T ARJAN强连通分量 (7)|弦图判断 (7)|弦图的PERFECT ELIMINATION点排列 (7)|稳定婚姻问题O(N^2) (7)|拓扑排序 (8)|无向图连通分支(DFS/BFS邻接阵) (8)|有向图强连通分支(DFS/BFS邻接阵)O(N^2) (8)|有向图最小点基(邻接阵)O(N^2) (9)|F LOYD求最小环 (9)|2-SAT问题 (9)Network 网络流 (11)|二分图匹配（匈牙利算法DFS实现） (11)|二分图匹配（匈牙利算法BFS实现） (11)|二分图匹配（H OPCROFT－C ARP的算法） (11)|二分图最佳匹配（KUHN MUNKRAS算法O(M*M*N)）..11 |无向图最小割O(N^3) (12)|有上下界的最小(最大)流 (12)|D INIC最大流O(V^2*E) (12)|HLPP最大流O(V^3) (13)|最小费用流O(V*E* F).......................................13|最小费用流O(V^2* F). (14)|最佳边割集 (15)|最佳点割集 (15)|最小边割集 (15)|最小点割集（点连通度） (16)|最小路径覆盖O(N^3) (16)|最小点集覆盖 (16)Structure 数据结构 (17)|求某天是星期几 (17)|左偏树合并复杂度O(LOG N) (17)|树状数组 (17)|二维树状数组 (17)|T RIE树(K叉) (17)|T RIE树(左儿子又兄弟) (18)|后缀数组O(N* LOG N) (18)|后缀数组O(N) (18)|RMQ离线算法O(N*LOG N)+O(1) (19)|RMQ(R ANGE M INIMUM/M AXIMUM Q UERY)-ST算法(O(NLOGN +Q)) (19)|RMQ离线算法O(N*LOG N)+O(1)求解LCA (19)|LCA离线算法O(E)+O(1) (20)|带权值的并查集 (20)|快速排序 (20)|2台机器工作调度 (20)|比较高效的大数 (20)|普通的大数运算 (21)|最长公共递增子序列O(N^2) (22)|0-1分数规划 (22)|最长有序子序列（递增/递减/非递增/非递减） (22)|最长公共子序列 (23)|最少找硬币问题（贪心策略-深搜实现） (23)|棋盘分割 (23)|汉诺塔 (23)|STL中的PRIORITY_QUEUE (24)|堆栈 (24)|区间最大频率 (24)|取第K个元素 (25)|归并排序求逆序数 (25)|逆序数推排列数 (25)|二分查找 (25)|二分查找（大于等于V的第一个值） (25)|所有数位相加 (25)Number 数论 (26)|递推求欧拉函数PHI(I) (26)|单独求欧拉函数PHI(X) (26)|GCD最大公约数 (26)|快速GCD (26)|扩展GCD (26)|模线性方程 A * X = B (% N) (26)|模线性方程组 (26)|筛素数[1..N] (26)|高效求小范围素数[1..N] (26)|随机素数测试(伪素数原理) (26)|组合数学相关 (26)|P OLYA计数 (27)|组合数C(N, R) (27)|最大1矩阵 (27)|约瑟夫环问题（数学方法） (27)|约瑟夫环问题（数组模拟） (27)|取石子游戏1 (27)|集合划分问题 (27)|大数平方根（字符串数组表示） (28)|大数取模的二进制方法 (28)|线性方程组A[][]X[]=B[] (28)|追赶法解周期性方程 (28)|阶乘最后非零位,复杂度O(NLOGN) (29)递归方法求解排列组合问题 (30)|类循环排列 (30)|全排列 (30)|不重复排列 (30)|全组合 (31)|不重复组合 (31)|应用 (31)模式串匹配问题总结 (32)|字符串H ASH (32)|KMP匹配算法O(M+N) (32)|K ARP-R ABIN字符串匹配 (32)|基于K ARP-R ABIN的字符块匹配 (32)|函数名: STRSTR (32)|BM算法的改进的算法S UNDAY A LGORITHM (32)|最短公共祖先（两个长字符串） (33)|最短公共祖先（多个短字符串）...............................33Geometry 计算几何.. (34)|G RAHAM求凸包O(N* LOG N) (34)|判断线段相交 (34)|求多边形重心 (34)|三角形几个重要的点 (34)|平面最近点对O(N* LOG N) (34)|L IUCTIC的计算几何库 (35)|求平面上两点之间的距离 (35)|(P1-P0)*(P2-P0)的叉积 (35)|确定两条线段是否相交 (35)|判断点P是否在线段L上 (35)|判断两个点是否相等 (35)|线段相交判断函数 (35)|判断点Q是否在多边形内 (35)|计算多边形的面积 (35)|解二次方程A X^2+B X+C=0 (36)|计算直线的一般式A X+B Y+C=0 (36)|点到直线距离 (36)|直线与圆的交点，已知直线与圆相交 (36)|点是否在射线的正向 (36)|射线与圆的第一个交点 (36)|求点P1关于直线LN的对称点P2 (36)|两直线夹角（弧度） (36)ACM/ICPC竞赛之STL (37)ACM/ICPC竞赛之STL简介 (37)ACM/ICPC竞赛之STL--PAIR (37)ACM/ICPC竞赛之STL--VECTOR (37)ACM/ICPC竞赛之STL--ITERATOR简介 (38)ACM/ICPC竞赛之STL--STRING (38)ACM/ICPC竞赛之STL--STACK/QUEUE (38)ACM/ICPC竞赛之STL--MAP (40)ACM/ICPC竞赛之STL--ALGORITHM (40)STL IN ACM (41)头文件 (42)线段树 (43)求矩形并的面积（线段树+离散化+扫描线） (43)求矩形并的周长（线段树+离散化+扫描线） (44)Graph 图论/*==================================================*\| DAG的深度优先搜索标记| INIT: edge[][]邻接矩阵; pre[], post[], tag全置0;| CALL: dfstag(i, n); pre/post:开始/结束时间\*==================================================*/int edge[V][V], pre[V], post[V], tag;void dfstag(int cur, int n){ // vertex: 0 ~ n-1pre[cur] = ++tag;for (int i=0; i<n; ++i) if (edge[cur][i]) {if (0 == pre[i]) {printf("Tree Edge!\n");dfstag(i,n);} else {if (0 == post[i]) printf("Back Edge!\n");else if (pre[i] > pre[cur])printf("Down Edge!\n");else printf("Cross Edge!\n");}}post[cur] = ++tag;}/*==================================================*\| 无向图找桥| INIT: edge[][]邻接矩阵;vis[],pre[],anc[],bridge 置0;| CALL: dfs(0, -1, 1, n);\*==================================================*/int bridge, edge[V][V], anc[V], pre[V], vis[V];void dfs(int cur, int father, int dep, int n){ // vertex: 0 ~ n-1if (bridge) return;vis[cur] = 1; pre[cur] = anc[cur] = dep;for (int i=0; i<n; ++i) if (edge[cur][i]) {if (i != father && 1 == vis[i]) {if (pre[i] < anc[cur])anc[cur] = pre[i];//back edge}if (0 == vis[i]) { //tree edgedfs(i,cur,dep+1,n);if (bridge) return;if (anc[i] < anc[cur]) anc[cur] = anc[i];if (anc[i] > pre[cur]) { bridge = 1; return; } }}vis[cur] = 2;}/*==================================================*\| 无向图连通度(割)| INIT: edge[][]邻接矩阵;vis[],pre[],anc[],deg[]置为0;| CALL: dfs(0, -1, 1, n);| k=deg[0], deg[i]+1(i=1…n-1)为删除该节点后得到的连通图个数| 注意:0作为根比较特殊!\*==================================================*/int edge[V][V], anc[V], pre[V], vis[V], deg[V];void dfs(int cur, int father, int dep, int n){// vertex: 0 ~ n-1int cnt = 0;vis[cur] = 1; pre[cur] = anc[cur] = dep;for (int i=0; i<n; ++i) if (edge[cur][i]) {if (i != father && 1 == vis[i]) {if (pre[i] < anc[cur])anc[cur] = pre[i];//back edge}if (0 == vis[i]) { //tree edgedfs(i,cur,dep+1,n);++cnt; // 分支个数if (anc[i] < anc[cur]) anc[cur] = anc[i];if ((cur==0 && cnt>1) ||(cnt!=0 && anc[i]>=pre[cur]))++deg[cur];// link degree of a vertex }}vis[cur] = 2;} /*==================================================*\| 最大团问题 DP + DFS| INIT: g[][]邻接矩阵;| CALL: res = clique(n);\*==================================================*/int g[V][V], dp[V], stk[V][V], mx;int dfs(int n, int ns, int dep){if (0 == ns) {if (dep > mx) mx = dep;return 1;}int i, j, k, p, cnt;for (i = 0; i < ns; i++) {k = stk[dep][i]; cnt = 0;if (dep + n - k <= mx) return 0;if (dep + dp[k] <= mx) return 0;for (j = i + 1; j < ns; j++) {p=stk[dep][j];if (g[k][p]) stk[dep + 1][cnt++] = p;}dfs(n, cnt, dep + 1);}return 1;}int clique(int n){int i, j, ns;for (mx = 0, i = n - 1; i >= 0; i--) {// vertex: 0 ~ n-1for (ns = 0, j = i + 1; j < n; j++)if (g[i][j]) stk[1][ ns++ ] = j;dfs(n, ns, 1); dp[i] = mx;}return mx;}/*==================================================*\| 欧拉路径O(E)| INIT: adj[][]置为图的邻接表; cnt[a]为a点的邻接点个数;| CALL: elpath(0); 注意:不要有自向边\*==================================================*/int adj[V][V], idx[V][V], cnt[V], stk[V], top;int path(int v){for (int w ; cnt[v] > 0; v = w) {stk[ top++ ] = v;w = adj[v][ --cnt[v] ];adj[w][ idx[w][v] ] = adj[w][ --cnt[w] ];// 处理的是无向图—-边是双向的，删除v->w后，还要处理删除w->v}return v;}void elpath (int b, int n){ // begin from b int i, j;for (i = 0; i < n; ++i) // vertex: 0 ~ n-1 for (j = 0; j < cnt[i]; ++j)idx[i][ adj[i][j] ] = j;printf("%d", b);for (top = 0; path(b) == b && top != 0; ) {b = stk[ --top ];printf("-%d", b);}printf("\n");}/*==================================================*\| Dijkstra数组实现O（N^2）| Dijkstra --- 数组实现(在此基础上可直接改为STL的Queue实现)| lowcost[] --- beg到其他点的最近距离| path[] -- beg为根展开的树，记录父亲结点\*==================================================*/#define INF 0x03F3F3F3Fconst int N;int path[N], vis[N];void Dijkstra(int cost[][N], int lowcost[N], int n, int beg){ int i, j, min;memset(vis, 0, sizeof(vis));vis[beg] = 1;for (i=0; i<n; i++){lowcost[i] = cost[beg][i]; path[i] = beg;}lowcost[beg] = 0;path[beg] = -1; // 树根的标记int pre = beg;for (i=1; i<n; i++){min = INF;dist[v] = dist[u] + c;for (j=0; j<n; j++)// 下面的加法可能导致溢出,INF 不能取太大if (vis[j]==0 &&lowcost[pre]+cost[pre][j]<lowcost[j]){lowcost[j] =lowcost[pre] + cost[pre][j]; path[j] = pre; } for (j=0; j<n; j++) if (vis[j] == 0 && lowcost[j] < min){ min = lowcost[j]; pre = j; } vis[pre] = 1; } } /*==================================================*\ | Dijkstra O(E * log E) | INIT: 调用init(nv, ne)读入边并初始化; | CALL: dijkstra(n, src); dist[i]为src 到i 的最短距离 \*==================================================*/ #define typec int // type of cost const typec inf = 0x3f3f3f3f; // max of cost typec cost[E], dist[V]; int e, pnt[E], nxt[E], head[V], prev[V], vis[V]; struct qnode { int v; typec c; qnode (int vv = 0, typec cc = 0) : v(vv), c(cc) {} bool operator < (const qnode& r) const { return c>r.c; } }; void dijkstra(int n, const int src){ qnode mv; int i, j, k, pre; priority_queue<qnode> que; vis[src] = 1; dist[src] = 0; que.push(qnode(src, 0)); for (pre = src, i=1; i<n; i++) { for (j = head[pre]; j != -1; j = nxt[j]) { k = pnt[j]; if (vis[k] == 0 && dist[pre] + cost[j] < dist[k]){ dist[k] =dist[pre] + cost[j]; que.push(qnode(pnt[j], dist[k])); prev[k] = pre; } } while (!que.empty() && vis[que.top().v] == 1) que.pop(); if (que.empty()) break ; mv = que.top(); que.pop(); vis[pre = mv.v] = 1; } } inline void addedge(int u, int v, typec c){ pnt[e] = v; cost[e] = c; nxt[e] = head[u]; head[u] = e++; } void init(int nv, int ne){ int i, u, v; typec c; e = 0;memset(head, -1, sizeof (head));memset(vis, 0, sizeof (vis));memset(prev, -1, sizeof (prev));for (i = 0; i < nv; i++) dist[i] = inf;for (i = 0; i < ne; ++i) {scanf("%d%d%d", &u, &v, &c);// %d: type of cost addedge(u, v, c); // vertex: 0 ~ n-1, 单向边 }}/*==================================================*\| BellmanFord 单源最短路O(VE)| 能在一般情况下，包括存在负权边的情况下，解决单源最短路径问题| INIT: edge[E][3]为边表| CALL: bellman(src);有负环返回0;dist[i]为src 到i 的最短距| 可以解决差分约束系统: 需要首先构造约束图，构造不等式时>=表示求最小值, 作为最长路，<=表示求最大值, 作为最短路 （v-u <= c:a[u][v] = c ）\*==================================================*/#define typec int // type of costconst typec inf=0x3f3f3f3f; // max of costint n, m, pre[V], edge[E][3];typec dist[V];int relax (int u, int v, typec c){if (dist[v] > dist[u] + c) {pre[v] = u; return 1; } return 0; } int bellman (int src){ int i, j;for (i=0; i<n; ++i) { dist[i] = inf; pre[i] = -1; } dist[src] = 0; bool flag; for (i=1; i<n; ++i){ flag = false; // 优化 for (j=0; j<m; ++j) { if( 1 == relax(edge[j][0], edge[j][1], edge[j][2]) ) flag = true; } if( !flag ) break; } for (j=0; j<m; ++j) { if (1 == relax(edge[j][0], edge[j][1], edge[j][2])) return 0; // 有负圈 } return 1; } /*==================================================*\ | SPFA(Shortest Path Faster Algorithm) Bellman-Ford 算法的一种队列实现，减少了不必要的冗余计算。
02最小生成树
范例：制造系统的分组技术
建模
设用Mi表示需由机器i加工的零件集，对任 意两台机器i,j, 定义相异度：
(i, j) | Mi M j | | Mi M j |
建模
(i, j) | Mi M j | | Mi M j |
“”：对称差， 分子：在机器i但不在机器j上加工，或在机 器j但不在机器i上加工的零件数。 分母：或在机器i，或在机器j上加工的零件数。 显然 01
最小生成树
一些常见的树形结构
无向树的定义
无向树: 连通无回路的无向图 平凡树: 平凡图 森林: 每个连通分支都是树的非连通的无向图 树叶: 树中度数为1的顶点 分支点: 树中度数2的顶点 例如
(a)
(b)
子图
定义设G=<V,E>, G=<V,E>是2个图(同为无向图,或同 为有向图) 若VV且EE, 则称G为G的子图, G为G的母图, 记作 GG 若GG 且V=V, 则称G为G的生成子图 设VV且V, 以V为顶点集, 以两端点都在V中的所有 边为边集的G的子图称作V的导出子图, 记作G[V] 设EE且E, 以E为边集, 以E中边关联的所有顶点为 顶点集的G的子图称作E的导出子图, 记作G[E]
范例：制造系统的分组技术
分组技术是设计制造系统的一种方法，它把生 产零件的机器分组，相应地把需生产的零件分类，使 零件跨组加工的情形尽量少，最理想的情况是使每个 零件的加工，都在组内完成。 假设有13种零件，需在9台机器上加工。在各台 机器上加工的零件号在下表中给出。
范例：制造系统的分组技术
机器 加工 的零 件 1 2,3, 7,8, 9,12 ,13 2 2,7, 8,11 ,12, 3 1,6 表 4 5 3,5, 3,7, 10 8,9, 12, 13 6 5 7 4,10 8 4,10 9 6
最小生成树和最短路径 -回复
最小生成树和最短路径-回复什么是最小生成树和最短路径？如何确定它们？这两个概念通常在计算机科学中被广泛应用于解决图论中的相关问题。
在这篇文章中，我们将一步一步地回答这些问题。
首先，让我们来了解最小生成树是什么。
在图论中，最小生成树是一个连通无向图的生成树，其所有边的权重之和最小，并且包含该图的所有顶点。
生成树是一种树状结构，它是由图中所有的顶点以及它们之间的一些边组成，并且这些边必须满足以下条件：它们连接图中的不同顶点，并且不形成环。
为了更好地理解这个定义，让我们通过一个简单的例子来说明最小生成树的概念。
假设我们有一个城市网络，城市之间的路径可以用边来表示，边上的权重表示两个城市之间的距离。
现在我们的目标是建设一条最小的路径，连接这些城市，使得整个网络的总距离最小。
这条路径就是最小生成树。
那么如何确定最小生成树呢？在解决这个问题时，我们可以使用一些经典的算法，其中最著名的是普里姆算法和克鲁斯卡尔算法。
普里姆算法是一种贪心算法，在每一步中选择一个顶点并将其加入最小生成树中，然后选择一个连通该顶点的边权重最小的顶点，将其也加入最小生成树中。
这个过程会一直重复，直到所有的顶点都被添加到最小生成树中。
克鲁斯卡尔算法也是一种贪心算法，它首先将所有的边按权重进行排序，然后从最小权重的边开始，依次将边添加到最小生成树中，直到所有的顶点都被连接起来。
在添加每一条边时，需要判断是否会形成环，如果会形成环，则不选择该边。
当然，最小生成树不止有普里姆算法和克鲁斯卡尔算法这两种求解方法，还有其他一些算法，例如克鲁斯卡尔算法的变体Prim-Dijkstra算法和Boruvka算法等等。
每种算法都有其自身的特点和适用场景，根据具体的问题需求选择合适的算法进行求解。
接下来，让我们来了解最短路径是什么。
在一个加权有向图中，最短路径是指两个顶点之间的路径，其边的权重之和最小。
最短路径问题在计算机科学中有许多应用，例如导航系统、网络路由以及大规模数据处理等领域。
最小树与最小树形图(数学建模)讲解
最小树与最小树形图（数学建模）讲解一、最小树的定义及性质1. 定义：最小树，又称最小树，是指在给定的带权无向图中，包含图中所有顶点的一个树形结构，且树中所有边的权值之和最小。
2. 性质：（1）最小树中不存在回路；（2）对于最小树中的任意两个顶点，它们之间有且仅有一条路径；（3）最小树中边的数量等于顶点数量减一；（4）在最小树中添加任意一条边，都会形成一条回路；（5）最小树不唯一，但权值之和相同。
二、求解最小树的方法1. Prim算法Prim算法是一种贪心算法，其基本思想是从图中的一个顶点开始，逐步添加边和顶点，直到形成最小树。
具体步骤如下：（1）初始化：选择一个顶点作为最小树的起点，将其加入最小树集合；（2）迭代：在最小树集合和非最小树集合之间，寻找一条权值最小的边，将其加入最小树集合；（3）重复步骤2，直到所有顶点都加入最小树集合。
2. Kruskal算法Kruskal算法同样是一种贪心算法，其基本思想是将图中的所有边按权值从小到大排序，然后依次选择权值最小的边，判断是否形成回路，若不形成回路，则将其加入最小树集合。
具体步骤如下：（1）初始化：将所有顶点视为独立的树；（2）按权值从小到大排序所有边；（3）迭代：选择权值最小的边，判断其是否形成回路，若不形成回路，则将其加入最小树集合；（4）重复步骤3，直到所有顶点都在同一棵树中。
三、最小树形图的定义及求解方法1. 定义：最小树形图，又称最优树形图，是指在给定的有向图中，找到一个包含所有顶点的树形结构，使得树中所有边的权值之和最小。
2. 求解方法：朱刘算法（Edmonds' Algorithm）朱刘算法是一种用于求解最小树形图的算法，其基本思想是通过寻找图中的最小权值环，进行收缩和扩展操作，最终得到最小树形图。
具体步骤如下：（1）寻找最小权值环；（2）对最小权值环进行收缩操作，将环中的顶点合并为一个新顶点；（3）在新图中寻找最小树形图；（4）将新图中的最小树形图扩展回原图，得到原图的最小树形图。
斯坦纳树算法
斯坦纳树算法
斯坦纳树算法，也称为“终极斯坦纳树算法”，是一种用于解决带权图中的最小树形图问题的算法。
该算法具有时间复杂度为O（n^3 * 2^n）的特点，因此适用于小型图和中等规模的图，但在大型图上会出现运行时间过长的问题。
斯坦纳树算法的基本思想是将原图中的顶点集合划分成若干个
子集，然后对每个子集构建一棵最小树形图，最后将所有子集的最小树形图合并成一棵最终的最小树形图。
该算法的核心在于如何构建子集的最小树形图，这通常使用DP（动态规划）的方式进行求解。
具体而言，斯坦纳树算法的步骤如下：
1.将所有边的权值取对数，并对原图做一些预处理，以提高算法效率。
2.对于每个子集S，使用DP的方式计算S中所有点到S中某个点的最短距离，记为d(S,v)，其中v是S中任意一个点。
3.对于每个子集S，将S中所有点连成一棵生成树，使得该树的根节点为S中某个点，且所有连边的权值之和等于d(S,v)。
4.通过枚举所有的子集S，计算每个子集的最小树形图，并记录下最小树形图的权值。
5.将所有子集的最小树形图合并成一棵最终的最小树形图。
需要注意的是，斯坦纳树算法只适用于有向图，且存在一些限制条件，如原图必须联通等。
此外，该算法在实际应用中，可能需要结合其他算法一起使用，以解决一些特殊情况下的问题。
最小生成树（Kruskal和Prim算法）
最⼩⽣成树（Kruskal和Prim算法）关于图的⼏个概念定义：关于图的⼏个概念定义：连通图：在⽆向图中，若任意两个顶点vi与vj都有路径相通，则称该⽆向图为连通图。
强连通图：在有向图中，若任意两个顶点vi与vj都有路径相通，则称该有向图为强连通图。
连通⽹：在连通图中，若图的边具有⼀定的意义，每⼀条边都对应着⼀个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通⽹。
⽣成树：⼀个连通图的⽣成树是指⼀个连通⼦图，它含有图中全部n个顶点，但只有⾜以构成⼀棵树的n-1条边。
⼀颗有n个顶点的⽣成树有且仅有n-1条边，如果⽣成树中再添加⼀条边，则必定成环。
最⼩⽣成树：在连通⽹的所有⽣成树中，所有边的代价和最⼩的⽣成树，称为最⼩⽣成树。
构造最⼩⽣成树的准则有3条：（1）必须只使⽤该⽹络中的边来构造最⼩⽣成树。
（2）必须使⽤且仅使⽤n-1条边来连接⽹络中的n个顶点。
（3）不能使⽤产⽣回路的边。
下⾯介绍两种求最⼩⽣成树算法1 Prim（普利姆算法）算法--加点法此算法可以称为“加点法”，每次迭代选择代价最⼩的边对应的点，加⼊到最⼩⽣成树中。
算法从某⼀个顶点s开始，逐渐长⼤覆盖整个连通⽹的所有顶点。
Prim算法从任意⼀个顶点开始，每次选择⼀个与当前顶点集最近的⼀个顶点，并将两顶点之间的边加⼊到树中。
Prim算法在找当前最近顶点时使⽤到了贪婪算法。
实现过程：5int logo[1010];///⽤0和1来表⽰是否被选择过6int map1[1010][1010];7int dis[1010];///记录任意⼀点到这⼀点的最近的距离8int n,m;9int prim()10 {11int i,j,now;12int sum=0;13for(i=1;i<=n;i++)///初始化14 {15 dis[i]=MAX;16 logo[i]=0;17 }18for(i=1;i<=n;i++)19 {20 dis[i]=map1[1][i];21 }22 dis[1]=0;23 logo[1]=1;24for(i=1;i<n;i++)///循环查找25 {26 now=MAX;27int min1=MAX;28for(j=1;j<=n;j++)29 {30if(logo[j]==0&&dis[j]<min1)31 {32 now=j;33 min1=dis[j];34 }35 }36if(now==MAX)///防⽌不成图37 {38break;39 }40 logo[now]=1;41 sum=sum+min1;42for(j=1;j<=n;j++)///填⼊新点后更新最⼩距离，到顶点集的距离43 {44if(logo[j]==0&&dis[j]>map1[now][j])45 {46 dis[j]=map1[now][j];47 }48 }49 }50if(i<n)51 {52 printf("?\n");53 }54else55 {56 printf("%d\n",sum);57 }58 }59int main()60 {61while(scanf("%d%d",&m,&n)!=EOF)///n是点数62 {63if(m==0)64 {65break;66 }67 memset(map1,0x3f3f3f3f,sizeof(map1));///map是邻接矩阵储存图的信息68for(int i=0;i<m;i++)69 {70int a,b,c;71 scanf("%d%d%d",&a,&b,&c);72if(c<map1[a][b])///防⽌出现重边73 {74 map1[a][b]=map1[b][a]=c;75 }76 }77 prim();78 }79return0;80 }邻接表实现：1 #include<stdio.h>2 #include<string.h>3 #include<vector>4 #include<algorithm>5#define INF 0x3f3f3f3f6using namespace std;7struct node8 {9int end;///终点10int power;///权值11 } t;12int n;///n为点数13 vector<node>q[500001];///邻接表储存图的信息14int dis[500001];///距离15int vis[500001];///标记数组16void prime()17 {18int i,len,j,pos,sum,start;19 memset(vis,0,sizeof(vis));20 sum=0;21 start=1;///任意取起点22for(i=0; i<=n; i++)23 {24 dis[i]=INF;25 }26 len=q[start].size();27for(i=0; i<len; i++)///从任意起点开始的dis数组更新28 {29if(q[start][i].power<dis[q[start][i].end])30 {31 dis[q[start][i].end]=q[start][i].power;32 }33 }34 vis[start]=1;35for(j=0; j<n-1; j++)36 {37int pos,min=INF;38for(i=1; i<=n; i++)39 {40if(vis[i]!=0&&dis[i]<min)41 {42 min=dis[i];43 pos=i;///找到未访问节点中权值最⼩的44 }45 }46if(pos==INF)///防⽌不成图47 {48break;49 }50 vis[pos]=1;51 sum=sum+min;52 len=q[pos].size();///再次更新dis数组53for(j=0; j<len; j++)54 {55if(vis[q[pos][j].end]==0&&dis[q[pos][j].end]>q[pos][j].power)56 {57 dis[q[pos][j].end] = q[pos][j].power;58 }59 }60 }61if(j<n)62 {63 printf("?\n");64 }65else66 {67 printf("%d\n",sum);68 }69 }70int main()71 {72int m,i;73int begin,end,power;74int a,b;75while(scanf("%d%d",&n,&m)!=EOF)76 {77for(i=0; i<=n; i++)78 {79 q[i].clear();///将victor数组清空80 }81for(i=0; i<m; i++)82 {83 scanf("%d%d%d",&begin,&end,&power);///输⼊84 t.end=end;85 t.power=power;86 q[begin].push_back(t);87 t.end=begin;///⽆向图88 t.power=power;89 q[end].push_back(t);90 }91 prime();92 }93return0;94 }这⾥再给出⼀个没有使⽤标记数组的代码：int prim(int s){int i,j,sum=0;int now;for(i=1;i<=n;i++){closest[i]=INT_MAX;}for(i=1;i<=n;i++){closest[i]=map[s][i];}closest[s]=0;for(i=1;i<n;i++)//这⾥的i代表的是边数，有n个点就会有n-1条边{int min=INT_MAX;for(j=1;j<=n;j++){if(closest[j]&&closest[j]<min){min=closest[j];now=j;//找到所需的最⼩边}}sum+=min;closest[now]=0;//将找到的边加⼊到最⼩⽣成树之中for(j=1;j<=n;j++)//找到新的点加⼊已选点集合之后，更新该点到未选点集合的距离{if(map[now][j]&&map[now][j]<closest[j]){closest[j]=map[now][j];}}}return sum;}2 Kruskal（克鲁斯卡尔）算法--加边法1.概览 Kruskal算法是⼀种⽤来寻找最⼩⽣成树的算法，在剩下的所有未选取的边中，找最⼩边，如果和已选取的边构成回路，则放弃，选取次⼩边。
【算法】关于图论中的最小生成树（MinimumSpanningTree）详解
【算法】关于图论中的最⼩⽣成树（MinimumSpanningTree）详解什么是图(network)什么是最⼩⽣成树 (minimum spanning tree)最⼩⽣成树的算法这⾥的图当然不是我们⽇常说的图⽚或者地图。
通常情况下，我们把图看成是⼀种由“顶点”和“边”组成的抽象⽹络。
在各个“顶点“间可以由”边“连接起来，使两个顶点间相互关联起来。
图的结构可以描述多种复杂的数据对象，应⽤较为⼴泛，看下图：为了更好地说明问题，下⾯我们看⼀个⽐较⽼套的通信问题：在各⼤城市中建设通信⽹络，如下图所⽰，每个圆圈代表⼀座城市，⽽边上的数字代表了建⽴通信连接的价格。
那么，请问怎样才能以最⼩的价格使各⼤城市能直接或者间接地连接起来呢？我们需要注意两点：最⼩的价格各⼤城市可以是直接或者间接相连的稍稍留⼼可以发现，题⽬的要求是，城市只需要直接或者间接相连，因此，为了节省成本，我们稍稍优化⼀下上述⽅案如下：可以看到，我们砍掉了原先在AD，BE之间的两条道路，建设价格⾃然就降下来了。
当然这个⽅案也是符合我们题⽬的要求的。
按照国际惯例，这⾥要说蛋是了。
上⾯的实例由于数据很简单，优化的⽅案很easy就看出来了。
但在实际中，数据量往往是⾮常庞⼤的。
所以，我们更倾向于设计⼀种⽅法，然后利⽤计算机强⼤的运算能⼒帮我们处理这些数据得出最优的⽅案。
那么，针对上述问题，我们⼀起来看看如何应⽤图的相关知识来实现吧。
为了直观，还是⽤图⽚给⼤家解释⼀下：对于⼀个图⽽⾔，它可以⽣成很多树，如右侧图2，图3就是由图1⽣成的。
从上⾯可以看出⽣成树是将原图的全部顶点以最少的边连通的⼦图，对于有n个顶点的连通图，⽣成树有n-1条边，若边数⼩于此数就不可能将各顶点连通，如果边的数量多于n-1条边，必定会产⽣回路。
对于⼀个带权连通图，⽣成树不同，树中各边上权值总和也不同，权值总和最⼩的⽣成树则称为图的最⼩⽣成树。
基本思想：假设有⼀个⽆向带权图G=(V,E)，它的最⼩⽣成树为MinTree=(V,T)，其中V为顶点集合，T为边的集合。
最小生成树,拓扑排序,强连通分量总结
h a
f
h
16
Kosaraju算法（双DFS） 实现算法： Tarjan算法 Gabow算法
DFN[i] / LOW[i] LOW[i] = 有未访问出边：min(LOW[i],DFN[nei(i)])
无未访问出边：min(LOW[i],LOW[son(i)])
DFN[i] : 结点i在深搜中的访问顺序
v2
v5
v4 v5 v6
v7
v5 v7 v8 v7 v4 v6 v2 v3 v1
出栈条件： 栈顶结点 的所有邻 接点都已 访问
实质：对每个顶点查找其邻接点
v1 v2 v4 v8 v5 v3
stack
v6 v7
v8
6
大纲
图的基础知识 DFS
基本的图算法
BFS 拓扑排序
强连通分量
最小生成树
7
3.BFS
1 /1
A
2 /2 /1
C
3 /3
E
初始：LOW[i] = DFN[i]
时间复杂度：O(n+e)
B D F
6 /6 /5
stack A C
5 /5 /1
D E F B
4 /4
出栈条件：LOW[i] = DFN[i]
强连通分量：{F}， {E}， {A,C ,D,B}
17
强连通分量是DFS树中的子树。 找到子树的根,从DFS树的最低层开始，求强连通分量。 DFN[i] = LOW[i]就出栈，表示i是强连通分量的根 为什么从DFS树最低层开始？
a
b
c
d
13/14
11 /16
1/10
8/9
12/15 e
3/4 f
伯克霍夫遍历定理
伯克霍夫遍历定理
伯克霍夫遍历定理（Berkhoff's theorem），也称为柏氏定理，是图论中的一个定理，它给出了有向图的生成树个数的计算方法。
伯克霍夫遍历定理的表述为：一个n个节点的有向图G，如果用行列式D(G)表示G的拉普拉斯矩阵的行列式（度矩阵减去邻接矩阵），那么G的生成树的个数等于D(G)中任意一个代数余子式的值。
具体来说，如果G的拉普拉斯矩阵的行列式D(G)中去掉第i 行和第j列，形成的新的矩阵的行列式为D_ij，那么G的生成树的个数等于D_ij的值。
伯克霍夫遍历定理的一个重要应用是计算有向图中的最小树形图，即以一个节点作为根节点的最小生成树。
利用伯克霍夫遍历定理，可以将最小树形图问题转化为计算有向图的生成树个数的问题，从而求解最优解。
总结起来，伯克霍夫遍历定理是一个用于计算有向图的生成树个数的定理，它通过拉普拉斯矩阵的代数余子式求解生成树个数，具有重要的理论和实际应用价值。
最小树形图
一．最小树形图最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。
最小树形图的第一个算法是1965年朱永津和刘振宏提出的复杂度为O(VE)的算法。
判断是否存在树形图的方法很简单，只需要以v为根作一次图的遍历就可以了，所以下面的算法中不再考虑树形图不存在的情况。
在所有操作开始之前，我们需要把图中所有的自环全都清除。
很明显，自环是不可能在任何一个树形图上的。
只有进行了这步操作，总算法复杂度才真正能保证是O(VE)。
首先为除根之外的每个点选定一条入边，这条入边一定要是所有入边中最小的。
现在所有的最小入边都选择出来了，如果这个入边集不存在有向环的话，我们可以证明这个集合就是该图的最小树形图。
这个证明并不是很难。
如果存在有向环的话，我们就要将这个有向环缩成一个人工顶点，同时改变图中边的权。
假设某点u在该环上，并设这个环中指向u的边权是in[u]，那么对于每条从u出发的边(u, i, w)，在新图中连接(new, i, w)的边，其中new为新加的人工顶点; 对于每条进入u的边(i, u, w)，在新图中建立边(i, new, w-in[u])的边。
为什么入边的权要减去in[u]，这个后面会解释，在这里先给出算法的步骤。
然后可以证明，新图中最小树形图的权加上旧图中被收缩的那个环的权和，就是原图中最小树形图的权。
上面结论也不做证明了。
现在依据上面的结论，说明一下为什么出边的权不变，入边的权要减去in [u]。
对于新图中的最小树形图T，设指向人工节点的边为e。
将人工节点展开以后，e指向了一个环。
假设原先e是指向u的，这个时候我们将环上指向u的边 in[u]删除，这样就得到了原图中的一个树形图。
我们会发现，如果新图中e的权w'(e)是原图中e的权w(e)减去in[u]权的话，那么在我们删除掉in[u]，并且将e恢复为原图状态的时候，这个树形图的权仍然是新图树形图的权加环的权，而这个权值正是最小树形图的权值。
【转】【最小树形图】有向图的最小生成树【朱刘算法】
【转】【最⼩树形图】有向图的最⼩⽣成树【朱刘算法】这篇⽂章挺好的。
每⾏还有注释QAQ，kuangbin的模板⾥并没有万能节点；万能节点好像是在不定根的时候的拓展。
要点：1.求所有边权和sum;2.以0点为万能节点向所有点建⼀条权值为sum的边；3.记得sum++；保证⽐所有边权值总和⼤⼀点；4.判断条件为(ans==-1 || ans-sum>=sum) //ans-sum是除去虚根的最⼩树形图的最短路径，如果这个距离⽐所有的边权值和sum还⼤，说明还有另外的边由虚点发出，故说明此图不连通5.答案即为ans-sum；做了POJ的⼀道题，总是WA，不知道为什么，后来去看了，才知道，原来有向图的最⼩⽣成树与⽆向图不⼀样，它得是从某个点出发能遍历到其他所有点的才⾏，以此为条件，我们学习到了最⼩树形图。
与很多其他⼈的讲解不⼀样吧，我把我看了博客后⾃⼰的思路分享出来，关于什么是最⼩树形图。
我们知道的既然要建⽴最⼩树形图，就要理解什么是最⼩树形图，（概念好难懂啊，还是⾃⼰写的清楚明⽩），我们从某⼀点出发（或者是固定点），能通过它跑完所有点的最⼩花费，就是最⼩树形图了。
那么，怎么去搭建最⼩树形图？会有⼈看到关于最⼩弧这样的讲法，诶！确实是这样的，但是你们理解什么是最⼩弧吗？我们想构建⼀颗最⼩⽣成树的时候，就是找到这样的最优解的边逐条放进去的（Kruskal算法思想），但是这也是⼀样的，我们找到所有⾮根节点的最⼩⼊边，先把这样的所有⼊边给加进来，那么得到的⼀幅图，可能还真是不完全，要是遇到了个环，岂不是有趣，或者呢，压根就⾛不完！不就GG？所以，就这样就被我们想出了两个需要判断的条件了。
把所有的最⼩⼊边先加起来，我们得到了⼀个花⾥胡哨的图，可能它就是多个环的集合，也许恰好是答案，这都是不确定的，若是恰好是已经没有环了，那么这就是答案了；反之，就是有环，那么，我们得到的边，就不⼀定是所有的点构在⼀起的图（也许会成为森林这样的情况），那么，把环搜索起来吧，我们把⼀个环搜索成⼀个点，然后对于它（新点——即所谓的缩点）的⼊边，我们建⽴新边的时候，需要考虑到我们得删除原来在这幅图⾥的改点的⼊边（就是我们已经存⼊了这个原节点的⼊边了，但是，它却构成了环，说明不是我想要的解），所以，新边的权值就是原权值减去终点节点的最⼩⼊边。
图论算法论文
1.Dijkstra（迪克斯屈拉算法）1)适用条件&范围：a)单源最短路径(从源点s到其它所有顶点v);b)有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图)c)所有边权非负(任取(i,j)∈E都有W ij≥0);2)算法描述：a)初始化：dis[v]=maxint(v∈V,v≠s); dis[s]=0; pre[s]=s;S={s};b)For i:=1 to n1.取V-S中的一顶点u使得dis[u]=min{dis[v]|v∈V-S}2.S=S+{u}3.For V-S中每个顶点v do Relax(u,v,W u,v)c)算法结束：dis[i]为s到i的最短距离；pre[i]为i的前驱节点3)算法优化：使用二叉堆(Binary Heap)来实现每步的DeleteMin(ExtractMin，即算法步骤b中第1步)操作，算法复杂度从O(V^2)降到O((V+E)㏒V)。
推荐对稀疏图使用。
使用Fibonacci Heap(或其他Decrease操作O(1),DeleteMin 操作O(logn)的数据结构)可以将复杂度降到O(E+V㏒V)；如果边权值均为不大于C的正整数，则使用Radix Heap可以达到O(E+V㏒C)。
但因为它们编程复杂度太高，不推荐在信息学竞赛中使用。
注：程序使用二叉堆程序：program mtx_grp;const num=10; max=10000;typegrp=array[1..num,1..num] of integer;rcd=set of 1..num;arr=array[1..num] of integer;arr2=array[1..num] of rcd;vari,j,w,m,n,e,k:integer;g:grp;visited:array[1..num] of boolean;path:arr2;dist,s:arr;procedure createmtx;var i,j,k:integer;beginfor i:=1 to n dofor j:=1 to n dog[i,j]:=max;for k:=1 to e dobeginreadln(i,j,w);g[i,j]:=w;g[j,i]:=w;end;end;procedure print( g:grp);beginfor i:=1 to n dobeginfor j:=1 to n doif g[i,j]=max then write('oo':4)else write(g[i,j]:4);writeln;end;end;procedure dijkstra(var dist:arr;var path:arr2;i:integer); begine:=i;for j:=1 to n do beginif j<>i then s[j]:=0 else s[j]:=1;dist[j]:=g[i,j];if dist[j]<maxthen path[j]:=[i]+[j]else path[j]:=[];end;for k:=1 to n-2 dobeginw:=max;m:=i;for j:=1 to n doif (s[j]=0) and (dist[j]<w) then begin m:=j;w:=dist[j];end;if m<>i then s[m]:=1 else exit;for j:=1 to n doif (s[j]=0) and (dist[m]+g[m,j]<dist[j])then begindist[j]:=dist[m]+g[m,j];path[j]:=path[m]+[j];end;end;for i:=1 to n doif i<>e then beginfor j:=1 to n doif j in path[i] then write(j:3);writeln('w=':4,dist[i]);end;end;beginassign(input,'nodelst5.in');reset(input);readln(n,e);createmtx;writeln;readln(i);dijkstra(dist,path,i);writeln;end.2.Floyd-Warshall1)适用范围：a)APSP(All Pairs Shortest Paths)b)稠密图效果最佳c)边权可正可负2)算法描述：a)初始化：dis[u,v]=w[u,v]b)For k:=1 to nFor i:=1 to nFor j:=1 to nIf dis[i,j]>dis[i,k]+dis[k,j] ThenDis[I,j]:=dis[I,k]+dis[k,j];c)算法结束：dis即为所有点对的最短路径矩阵3)算法小结：此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。