最小树形图

最新推荐文章于 2019-06-14 11:29:53 发布
最新推荐文章于 2019-06-14 11:29:53 发布
阅读量724 收藏
点赞数
分类专栏： ACM_图论 文章标签： 算法 command
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hqd_acm/article/details/6746726
版权

poj 3164  Command Network


#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define maxn 120
#define INF 99999999999.0
int n,m;
struct node
{
    double x,y;
} a[maxn];
inline double get_dis(node a,node b)
{
    return sqrt((a.x - b.x)*(a.x - b.x)+(a.y - b.y)*(a.y - b.y));
}
double map[maxn][maxn];
bool flag[maxn];
int pre[maxn];
void dfs(int x)
{
    flag[x]=true;
    for(int i=1; i<=n; i++)
        if(!flag[i]&&map[x][i]!=INF)
            dfs(i);
}
bool check()//检查联通
{
    memset(flag,0,sizeof(flag));
    dfs(1);
    for(int i=1; i<=n; i++)
        if(!flag[i])return false;
    return true;
}
double solve()
{
    memset(flag,0,sizeof(flag));//flag是true的点是被去掉的点
    int i,j,k;
    double ans=0;
    while(1)
    {
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                pre[i]=i;
                map[i][i]=INF;
                for(j=1; j<=n; j++)
                if(!flag[j])
                    {
                        if(map[pre[i]][i]>map[j][i])
                            pre[i]=j;
                    }
            }
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                bool mark[maxn];
                memset(mark,0,sizeof(mark));
                for(j=i; j!=1&&!mark[j]; mark[j]=true,j=pre[j]);
                //寻找环，返回在环内的一点（注意从i出发能找到换不代表n在环内）
                if(j==1)continue;
                i=j;
                ans+=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    ans+=map[pre[j]][j];
                    flag[j]=true;
                }
                for(j=1; j<=n; j++)if(!flag[j]&&map[j][i]!=INF)
                        map[j][i]-=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    for(k=1; k<=n; k++)if(!flag[k]&&map[j][k]!=INF)
                            map[i][k]=min(map[i][k],map[j][k]);
                    for(k=1; k<=n; k++)if(!flag[k]&&map[k][j]!=INF)
                            map[k][i]=min(map[k][i],map[k][j]-map[pre[j]][j]);
                }
                break;
            }
        if(i>n)//说明没有环了。
        {
            for(j=2; j<=n; j++)if(!flag[j])
                    ans+=map[pre[j]][j];
            return ans;
        }
    }
}
int main()
{
    int i,j,x,y;
    while(scanf("%d%d",&n,&m)!=-1)
    {
        for(i=1; i<=n; i++)
            scanf("%lf%lf",&a[i].x,&a[i].y);
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                map[i][j]=INF;
        for(i=1; i<=m; i++)
        {
            scanf("%d%d",&x,&y);
            if(x==y)continue;//消除自环
            map[x][y]=get_dis(a[x],a[y]);
        }
        if(!check())//检查有向图是否联通
        {
            printf("poor snoopy\n");
        }
        else
        {
            printf("%.2lf\n",solve());
        }
    }
}

/*
算法核心需要三个步骤：
①找出每个点最小的入边in[v],如果有除根节点之外的点没有入边，显然无解。
②累加出上面所有点的最小入边的值。
找出图中的环，如果没有环，终止，返回解；否则，缩点，转入第三步。
③重新构图。令每条点v的入边w的值都减去in[v]。转入第一步。

不固定根
作法是，新设置一个人工点，向每一个顶点连一条边（称为"另类边"），权值至少比原图所有边之和还大1。
然后，以改人工点为root，求一次最小树形图。并在过程中记录使用过的边（即每次找出的最小入边）。
如果使用的 "另类边" 的次数大于1，就是impossible.否则可以找出这条边，找出那个city即可。
因为要找最小的城市，所以，我们添加边的时候，按照城市依次添加边root-->城市i就好了。
*/


2248.   Channel Design


#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define maxn 102
#define INF 99999999
int n,m;
int map[maxn][maxn];
bool flag[maxn];
int pre[maxn];
void dfs(int x)
{
    flag[x]=true;
    for(int i=1; i<=n; i++)
        if(!flag[i]&&map[x][i]!=INF)
            dfs(i);
}
bool check()//检查联通
{
    memset(flag,0,sizeof(flag));
    dfs(1);
    for(int i=1; i<=n; i++)
        if(!flag[i])return false;
    return true;
}
int solve()
{
    memset(flag,0,sizeof(flag));//flag是true的点是被去掉的点
    int i,j,k;
    int ans=0;
    while(1)
    {
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                pre[i]=i;
                map[i][i]=INF;
                for(j=1; j<=n; j++)
                if(!flag[j])
                    {
                        if(map[pre[i]][i]>map[j][i])
                            pre[i]=j;
                    }
            }
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                bool mark[maxn];
                memset(mark,0,sizeof(mark));
                for(j=i; j!=1&&!mark[j]; mark[j]=true,j=pre[j]);
                //寻找环，返回在环内的一点（注意从i出发能找到换不代表n在环内）
                if(j==1)continue;
                i=j;
                ans+=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    ans+=map[pre[j]][j];
                    flag[j]=true;
                }
                for(j=1; j<=n; j++)if(!flag[j]&&map[j][i]!=INF)
                        map[j][i]-=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    for(k=1; k<=n; k++)if(!flag[k]&&map[j][k]!=INF)
                            map[i][k]=min(map[i][k],map[j][k]);
                    for(k=1; k<=n; k++)if(!flag[k]&&map[k][j]!=INF)
                            map[k][i]=min(map[k][i],map[k][j]-map[pre[j]][j]);
                }
                break;
            }
        if(i>n)//说明没有环了。
        {
            for(j=2; j<=n; j++)if(!flag[j])
                    ans+=map[pre[j]][j];
            return ans;
        }
    }
}
int main()
{
    while(scanf("%d%d", &n ,&m) != EOF)
    {
        if(n == 0 && m == 0)  break;

        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                map[i][j]=INF;

        int x, y, z;
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&x, &y, &z);
            if(x == y) continue;//消除自环
            map[x][y] = min(map[x][y], z);
        }

        if(!check())
        {
            printf("impossible\n");
        }
        else
        {
            printf("%d\n", solve());
        }
    }
    return 0;
}

/*
算法核心需要三个步骤：
①找出每个点最小的入边in[v],如果有除根节点之外的点没有入边，显然无解。
②累加出上面所有点的最小入边的值。
找出图中的环，如果没有环，终止，返回解；否则，缩点，转入第三步。
③重新构图。令每条点v的入边w的值都减去in[v]。转入第一步。

不固定根
作法是，新设置一个人工点，向每一个顶点连一条边（称为"另类边"），权值至少比原图所有边之和还大1。
然后，以改人工点为root，求一次最小树形图。并在过程中记录使用过的边（即每次找出的最小入边）。
如果使用的 "另类边" 的次数大于1，就是impossible.否则可以找出这条边，找出那个city即可。
因为要找最小的城市，所以，我们添加边的时候，按照城市依次添加边root-->城市i就好了。
*/


uva 11183 teen girl squad

#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define maxn 1052
#define INF 99999999
int n,m;
int map[maxn][maxn];
bool flag[maxn];
int pre[maxn];
void dfs(int x)
{
    flag[x]=true;
    for(int i=1; i<=n; i++)
        if(!flag[i]&&map[x][i]!=INF)
            dfs(i);
}
bool check()//检查联通
{
    memset(flag,0,sizeof(flag));
    dfs(1);
    for(int i=1; i<=n; i++)
        if(!flag[i])return false;
    return true;
}
int solve()
{
    memset(flag,0,sizeof(flag));//flag是true的点是被去掉的点
    int i,j,k;
    int ans=0;
    while(1)
    {
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                pre[i]=i;
                map[i][i]=INF;
                for(j=1; j<=n; j++)
                if(!flag[j])
                    {
                        if(map[pre[i]][i]>map[j][i])
                            pre[i]=j;
                    }
            }
        for(i=2; i<=n; i++)
        if(!flag[i])
            {
                bool mark[maxn];
                memset(mark,0,sizeof(mark));
                for(j=i; j!=1&&!mark[j]; mark[j]=true,j=pre[j]);
                //寻找环，返回在环内的一点（注意从i出发能找到换不代表n在环内）
                if(j==1)continue;
                i=j;
                ans+=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    ans+=map[pre[j]][j];
                    flag[j]=true;
                }
                for(j=1; j<=n; j++)if(!flag[j]&&map[j][i]!=INF)
                        map[j][i]-=map[pre[i]][i];
                for(j=pre[i]; j!=i; j=pre[j])
                {
                    for(k=1; k<=n; k++)if(!flag[k]&&map[j][k]!=INF)
                            map[i][k]=min(map[i][k],map[j][k]);
                    for(k=1; k<=n; k++)if(!flag[k]&&map[k][j]!=INF)
                            map[k][i]=min(map[k][i],map[k][j]-map[pre[j]][j]);
                }
                break;
            }
        if(i>n)//说明没有环了。
        {
            for(j=2; j<=n; j++)if(!flag[j])
                    ans+=map[pre[j]][j];
            return ans;
        }
    }
}
int main()
{
    int T, cas = 1;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n ,&m);
        if(n == 0 && m == 0)  break;

        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                map[i][j]=INF;

        int x, y, z;
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&x, &y, &z);
            x++;
            y++;
            if(x == y) continue;//消除自环
            map[x][y] = min(map[x][y], z);
        }

        if(!check())
        {
            printf("Case #%d: Possums!\n", cas++);
        }
        else
        {
            printf("Case #%d: %d\n", cas++, solve());
        }
    }
    return 0;
}

/*
算法核心需要三个步骤：
①找出每个点最小的入边in[v],如果有除根节点之外的点没有入边，显然无解。
②累加出上面所有点的最小入边的值。
找出图中的环，如果没有环，终止，返回解；否则，缩点，转入第三步。
③重新构图。令每条点v的入边w的值都减去in[v]。转入第一步。

不固定根
作法是，新设置一个人工点，向每一个顶点连一条边（称为"另类边"），权值至少比原图所有边之和还大1。
然后，以改人工点为root，求一次最小树形图。并在过程中记录使用过的边（即每次找出的最小入边）。
如果使用的 "另类边" 的次数大于1，就是impossible.否则可以找出这条边，找出那个city即可。
因为要找最小的城市，所以，我们添加边的时候，按照城市依次添加边root-->城市i就好了。
*/

hdu 2121  ice_cream's world ll


弄个虚拟根，代码不贴了，用的别人的模板






HQD因为有趣所以做题
关注
专栏目录
由坐标矩阵求最小生成树图形（原创无错可运行）
01-26
由坐标矩阵求最小生成树图形（原创无错可运行） 可改为邻接矩阵 老师作业题
HDU ACM 2121 Ice_cream’s world II （无根最小树形图）
weixin_34390105的博客
07-27 110
【解题思路】这题先看了NotOnlySuccess的解题思路，即设置虚根再处理的做法；弄了一个上午，再次有种赶脚的感觉~~如果需要找出为什么需要去比所有权值之和更大的数为新增的虚边的话，一开始我理解仅是找比最大边权值要大的数就够了，因为这样就已经满足了不会提前找到虚边的情况，但如果是这样的话那就很难判断这样一种情况：生成的最小树形图（含虚根）有两条边是从虚根出来的。 1 #incl...
[学习笔记]最小树形图
weixin_34329187的博客
01-07 134
处理这样一类问题： 给一个有向图，定义树形图：一个有向图以x为根的树形图，是一个n-1条边的集合，使得x能到达其他每一个点 树形图的权值定义为边的和 朱刘算法就是求最小树形图 方法： 1.给每个点p找一个边权最小的连向它的边，边权为val，前驱设为pre。找到了一个边集E0 ans记录总权值 2.检查，如果有一个孤立点（除了rt），那么无解，退出 如果没有有向环，那么完毕。当...
最小树形图（有向图的最小生成树）朱刘算法
ACM,再见！
07-20 1874
http://baike.baidu.com/view/5944982.htm?fr=aladdin
poj 3164 最小树形图
I will Do iT @ hlyblog.net
07-19 1073
最小树形图。就是从根节点出发，
最小树形图_树形图权_最小树形图虚根_
10-02
在计算机科学和图论中，"最小树形图"（Minimum Spanning Tree, MST）是一个经典问题，它涉及寻找一个无向加权图中的边子集，这些边连接了图中的所有顶点，且该子集的总权重尽可能小。在解决这个问题时，通常会用到...
zuixiaoshuxingtu.rar_最小树形图
09-22
最小树形图，也称为最小生成树，是图论中的一个重要概念，主要应用于网络优化问题，如设计最短路径、最低成本通信网络等。在这个压缩包文件“zuixiaoshuxingtu.rar”中，包含了一个名为“51CTO下载-最小树形图.txt”...
最小树形图模板朱刘算法分享
09-04
最小树形图模板朱刘算法分享 本篇文章主要介绍了最小树形图模板朱刘算法的实现细节，该算法用于解决最小树形图问题，它是图论中的一种经典问题。下面将详细介绍该算法的实现细节。 什么是最小树形图？ 在图论中，...
A-map-to-the-smallest-tree.rar_The Tree_最小树形图
09-24
在计算机科学领域，有向图最小树形图（Minimum Spanning Tree for Directed Graphs）是一个经典问题，尤其在算法设计和图论中占有重要地位。最小树形图问题旨在找到一个有向图的子集，使得这个子集中任意两个顶点...
最小树形图 朱刘算法.docx
05-06
最小树形图问题是一个经典的图论问题，主要目标是在给定的有向带权图中找到一棵以特定顶点（root）为根的有向生成树，使得这棵树的所有边的权重之和最小。朱刘算法，由朱永津和刘振宏在1965年提出，是一种有效解决此...
hdu4966 hdu4009 (最小树形图）
程序人生
08-20 656
  hdu4966 一开始以为是网络流，各种坑队友，后来才发现是相当裸的最小树形图。   添加一个根，连边到各课程的0级，权值为0。 然后每个课程从（i）级连边到（i-1）级，权值为0. 最后根据课程间的关系再连边。     #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;iostream&gt; u...
最小树形图【模板】
程序员充电站（itcharge）
05-03 1541
基于贪心和缩点的思想。 假设根的顶点是V0。 (1)除了根结点外，所有的点Vi，找到以Vi为终点的最短的边，加入集合中 （pre[v]存放的是终点v的起点,In[v]存放终点为v的最短的边） (2)检查集合中有没有有向环和收缩点。若没有有向环和收缩点，结束计算；若没有有向环、但含收缩边，则跳至步骤(4)；若含有有向环，则跳至步骤(3)。Ps：如果出现重边，将忽略权值较高的 (3)含有有向环
最小树形图模板（朱刘算法）
代码改变世界，keep coding。
10-11 1615
点的标号必须是0到n-1 必须去除到自身的边，到自身的边的权为无穷大 #include #include #include #define M 1007 #define inf 0x3f3f3f using namespace std; int pre[M],vis[M],id[M]; int in[M]; int n,m; struct Node//建立邻接表 { int u,
【算法精讲】最小树形图 (两份讲解 配套例题)
Suprit's blog
06-14 1748
其一 概述 最小树形图, 简而言之就是求有向带权图的最小生成树. 官方定义是这样的: 最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振宏提出的复杂度为O(VE)的算法：朱、刘算法。 今天我们就来浅谈一下最小树形图的问题。 最小树形图, 简而言之就是求有向带权图的最小生成树....
hdu4966 最小树形图（最少辅导花费）
天使也掉毛
08-21 681
题意：       以一些科目，和辅导班，每个科目最终要求修到某个等级，可以花一定的钱在辅导班把某一科目修到某一等级，进入辅导班的时候会有一个限制，那就是达到他给出的科目和等级限制，比如a b c d m的意思就是科目a必须达到b等级才可以花m钱把科目c修到d等级，最后问把所有 科目修到给定的等级要花的最小辅导费用。 思路：       我们可以把每一个科目的每一个等级看成一个
有向图 MST 最小树形图 刘朱算法
海上机械师
07-31 1544
复杂度 n^3 在一个有向图中寻找最小生成树，即加入所选边使得源点可以到达任一点 如果没有源点，可以考虑认为加入一个源点，视题目而定 const int maxn = 120; const double inf = 1000000000; struct Edge{ int u, v; double w; void Get( int a, int b, double c) { u
最小树形图模版
九野的博客
01-20 1763
以下来自kuangbin的最小树形图模版： #include #include #include #include #include using namespace std; /* * 最小树形图 * 复杂度O(NM) * 点从0开始 */ const int INF = 100000000; const int MAXN = 1010; //点数 const
最小树形图--有向图的最小生成树 poj 3164 Command Network
雪的期许
09-22 2280
【最小树形图】： 就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 最小树形图必须有一个根，而且选择不同的点作为根，也是不一样的结果。 最小树形图必须包含图中的每一个节点，并且均可通过有向边到达根节点root 最小树形图的第一个算法是 1965年朱永津和刘振宏提出的复杂度为O(VE)的算法。 Command Network Time Limit: 1000MS Memory Limit: 131072K Total Submissions:
朱、刘算法：求最小树形图权值个人理解+个人详解【最小树形图模板】
mengxiang000000
04-28 5776
什么是最小树形图？相信大家如果会过来看这篇文章，想必也应该对最小生成树有所了解的，最小生成树求的是无向图的一颗生成树的最小权值。我们的最小树形图就是来解决一个有向图的一颗生成树的最小权值，对于度娘来说，最小树形图是这样定义的：最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振
实现最小树形图路径输出的简易方法
资源摘要信息:"最小树形图" 最小树形图是一种用于解决网络流问题的数学概念，在计算机科学、运筹学和图论领域中有广泛应用。在最小树形图问题中，给定一个带权有向图，要求找到一个包含所有顶点的树形结构，使得树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值