程序博客网 > mpi编程是什么

最小树形图

来源：互联网 发布：mpi编程是什么 编辑：程序博客网 时间：2024/05/29 09:01


个人觉得这个博客把这个算法说的比较详细了，直接搬过来吧，我再阐述一遍的话没有人家说的好，还容易说错。
========================== 分割线之下摘自Sasuke_SCUT的blog==================================================
最 小树形图，就是给有向带权图中指定一个特殊的点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恢复为原图状态的时候，这个树形图的权仍然是新图树形图的权加环的权，而这个权值正是最小树形图的权值。所以在展开节点之后，我们 得到的仍然是最小树形图。逐步展开所有的人工节点，就会得到初始图的最小树形图了。
如果实现得很聪明的话，可以达到找最小入边O(E)，找环 O(V)，收缩O(E)，其中在找环O(V)这里需要一点技巧。这样每次收缩的复杂度是O(E)，然后最多会收缩几次呢？由于我们一开始已经拿掉了所有的 自环，我门可以知道每个环至少包含2个点，收缩成1个点之后，总点数减少了至少1。当整个图收缩到只有1个点的时候，最小树形图就不不用求了。所以我们最 多只会进行V-1次的收缩，所以总得复杂度自然是O(VE)了。由此可见，如果一开始不除去自环的话，理论复杂度会和自环的数目有关。
======================== 分割线之上摘自Sasuke_SCUT的blog=====================================================

下 面是朱刘算法的构造图


[cpp] view plaincopy
  1. #include <cstdio>  
  2. #include <iostream>  
  3. #include<queue>  
  4. #include<set>  
  5. #include<ctime>  
  6. #include<algorithm>  
  7. #include<cmath>  
  8. #include<vector>  
  9. #include<map>  
  10. #include<cstring>  
  11. using namespace std;  
  12. const double eps=1e-10;  
  13. #define M 109  
  14. #define type double   
  15. const type inf=(1)<<30;  
  16. struct point   
  17. {  
  18.     double x,y;  
  19. }p[M];  
  20. double dis(point a,point b)  
  21. {  
  22.     return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));  
  23. }  
  24. struct Node{  
  25.     int u , v;  
  26.     type cost;  
  27. }E[M*M+5];  
  28. int pre[M],ID[M],vis[M];  
  29. type In[M];  
  30. int n,m;   
  31. type Directed_MST(int root,int NV,int NE) {  
  32.     type ret = 0;  
  33.     while(true) {  
  34.         //1.找最小入边  
  35.         for(int i=0;i<NV;i++) In[i] = inf;  
  36.         for(int i=0;i<NE;i++){  
  37.             int u = E[i].u;  
  38.             int v = E[i].v;  
  39.             if(E[i].cost < In[v] && u != v) {  
  40.                 pre[v] = u;  
  41.                 In[v] = E[i].cost;  
  42.             }  
  43.         }  
  44.         for(int i=0;i<NV;i++) {  
  45.             if(i == root) continue;  
  46.             if(In[i] == inf)    return -1;//除了跟以外有点没有入边,则根无法到达它  
  47.         }  
  48.         //2.找环  
  49.         int cntnode = 0;  
  50.     //  CC(ID,-1);  
  51.     //  CC(vis,-1);  
  52.     memset(ID,-1,sizeof(ID));  
  53.     memset(vis,-1,sizeof(vis));  
  54.         In[root] = 0;  
  55.         for(int i=0;i<NV;i++) {//标记每个环  
  56.             ret += In[i];  
  57.             int v = i;  
  58.             while(vis[v] != i && ID[v] == -1 && v != root) {  
  59.                 vis[v] = i;  
  60.                 v = pre[v];  
  61.             }  
  62.             if(v != root && ID[v] == -1) {  
  63.                 for(int u = pre[v] ; u != v ; u = pre[u]) {  
  64.                     ID[u] = cntnode;  
  65.                 }  
  66.                 ID[v] = cntnode ++;  
  67.             }  
  68.         }  
  69.         if(cntnode == 0)    break;//无环  
  70.         for(int i=0;i<NV;i++) if(ID[i] == -1) {  
  71.             ID[i] = cntnode ++;  
  72.         }  
  73.         //3.缩点,重新标记  
  74.         for(int i=0;i<NE;i++) {  
  75.             int v = E[i].v;  
  76.             E[i].u = ID[E[i].u];  
  77.             E[i].v = ID[E[i].v];  
  78.             if(E[i].u != E[i].v) {  
  79.                 E[i].cost -= In[v];  
  80.             }  
  81.         }  
  82.         NV = cntnode;  
  83.         root = ID[root];  
  84.     }  
  85.     return ret;  
  86. }  
  87.   
  88.   
  89. int main()  
  90. {  
  91.     while(scanf("%d%d",&n,&m)!=EOF)  
  92.     {  
  93.         // memset(pre,0,sizeof(pre));  
  94.         for(int i=0;i<n;i++)  
  95.         scanf("%lf%lf",&p[i].x,&p[i].y);  
  96.         for(int i=0;i<m;i++)  
  97.         {  
  98.         scanf("%d%d",&E[i].u,&E[i].v);  
  99.         E[i].u--;  
  100.         E[i].v--;  
  101.         if(E[i].u!=E[i].v)  
  102.         E[i].cost=dis(p[E[i].u],p[E[i].v]);  
  103.         else E[i].cost=1<<30;  
  104.         }  
  105.         type ans=Directed_MST(0,n,m);  
  106.         if(ans==-1)  
  107.         printf("poor snoopy\n");  
  108.         else   
  109.         printf("%.2f\n",ans);  
  110.     }  
  111.     return 0;  
  112. }  

[cpp] view plaincopy
  1. #include <cstdio>  
  2. #include <iostream>  
  3. #include<queue>  
  4. #include<set>  
  5. #include<ctime>  
  6. #include<algorithm>  
  7. #include<cmath>  
  8. #include<vector>  
  9. #include<map>  
  10. #include<cstring>  
  11. using namespace std;  
  12. const double eps=1e-10;  
  13. #define M 109  
  14. #define type int  
  15. const type inf=(1)<<30;  
  16. struct point   
  17. {  
  18.     double x,y;  
  19. }p[M];  
  20. double dis(point a,point b)  
  21. {  
  22.     return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));  
  23. }  
  24. struct Node{  
  25.     int u , v;  
  26.     type cost;  
  27. }E[M*M+5];  
  28. int pre[M],ID[M],vis[M];  
  29. type In[M];  
  30. int n,m;   
  31. type Directed_MST(int root,int NV,int NE) {  
  32.     type ret = 0;  
  33.     while(true) {  
  34.         //1.找最小入边  
  35.         for(int i=0;i<NV;i++) In[i] = inf;  
  36.         for(int i=0;i<NE;i++){  
  37.             int u = E[i].u;  
  38.             int v = E[i].v;  
  39.             if(E[i].cost < In[v] && u != v) {  
  40.                 pre[v] = u;  
  41.                 In[v] = E[i].cost;  
  42.             }  
  43.         }  
  44.         for(int i=0;i<NV;i++) {  
  45.             if(i == root) continue;  
  46.             if(In[i] == inf)    return -1;//除了跟以外有点没有入边,则根无法到达它  
  47.         }  
  48.         //2.找环  
  49.         int cntnode = 0;  
  50.     memset(ID,-1,sizeof(ID));  
  51.     memset(vis,-1,sizeof(vis));  
  52.         In[root] = 0;  
  53.         for(int i=0;i<NV;i++) {//标记每个环  
  54.             ret += In[i];  
  55.             int v = i;  
  56.             while(vis[v] != i && ID[v] == -1 && v != root) {  
  57.                 vis[v] = i;  
  58.                 v = pre[v];  
  59.             }  
  60.             if(v != root && ID[v] == -1) {  
  61.                 for(int u = pre[v] ; u != v ; u = pre[u]) {  
  62.                     ID[u] = cntnode;  
  63.                 }  
  64.                 ID[v] = cntnode ++;  
  65.             }  
  66.         }  
  67.         if(cntnode == 0)    break;//无环  
  68.         for(int i=0;i<NV;i++) if(ID[i] == -1) {  
  69.             ID[i] = cntnode ++;  
  70.         }  
  71.         //3.缩点,重新标记  
  72.         for(int i=0;i<NE;i++) {  
  73.             int v = E[i].v;  
  74.             E[i].u = ID[E[i].u];  
  75.             E[i].v = ID[E[i].v];  
  76.             if(E[i].u != E[i].v) {  
  77.                 E[i].cost -= In[v];  
  78.             }  
  79.         }  
  80.         NV = cntnode;  
  81.         root = ID[root];  
  82.     }  
  83.     return ret;  
  84. }  
  85.   
  86.   
  87. int main()  
  88. {  
  89.     while(scanf("%d%d",&n,&m),n+m)  
  90.     {  
  91.         for(int i=0;i<m;i++)  
  92.         {  
  93.         scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].cost);  
  94.         E[i].u--;  
  95.         E[i].v--;  
  96.         }  
  97.         type ans=Directed_MST(0,n,m);  
  98.         if(ans==-1)  
  99.         printf("impossible\n");  
  100.         else   
  101.         printf("%d\n",ans);  
  102.     }  
  103.     return 0;  
  104. }  



0 0
mpi编程是什么 mpi编程是什么
原创粉丝点击
热门IT博客
八卦八卦我牵挂 知乎八卦八卦我牵挂 知乎
淘宝店铺登录界面淘宝店铺登录界面
js中join的用法
彩虹聊天软件
正确的多相睡眠 知乎
苹果不要软件自动更新
icmp是网络管理协议
mac os x10.10.5 dmg
淘宝集市店要交税吗
app下不了软件
java读取日志文件处理
淘宝差评被杀
淘宝免单群是真的吗
如何做网络主播
linux安装oracle9i
mac怎么玩ios手游
淘宝在线客服咨询
淘宝贷款入口
林心如人品知乎
bluefish淘宝
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 夫妻用品 健康养生知识 宝健 性趣用品 宝建 男女情趣用品 健康常识 男人保健品 性情趣用品 宝健中国 夫妻用品大全图片 男士保健品 性保药品 男性保保健品 男人的保健品 情趣用品商城 保建 女性成人用品 男人健康 中国宝健 男女用品 保健品男性 情趣故事 夫妻保健品 性保保健品批发 健康产品 养生品 健康测试 健康的生活方式 女人健康 39男人健康网 健康来了 养生艾灸 大健康 健康图片 健康产业网 000913农银医疗保健 000831工银医疗保健 保兑仓融资模式 财产保全 保全申请书

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里