【最小树形图】最小树形图复习

最新推荐文章于 2022-03-06 15:21:12 发布
最新推荐文章于 2022-03-06 15:21:12 发布
阅读量2.2k 收藏
点赞数
分类专栏： OI 文章标签： date command network system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whjpji/article/details/7690436
版权

模板题：

poj3164 Command Network

/***********************************\
 * @prob: poj3164 Command Network  *
 * @auth: Wang Junji               *
 * @stat: Accepted.                *
 * @date: June. 25th, 2012         *
 * @memo: 最小树形图                *
\***********************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>

const int maxN = 110;
const double INF = 1e198;

double mp[maxN][maxN], x[maxN], y[maxN];
bool del[maxN];
int pre[maxN], root, n, m;

template <typename _Tp>
inline _Tp& gmax(_Tp& a, const _Tp& b)
{return a > b ? a : (a = b);}
/* gmax */

template <typename _Tp>
inline _Tp& gmin(_Tp& a, const _Tp& b)
{return a < b ? a : (a = b);}
/* gmin */

template <typename _Tp>
inline _Tp sqr(const _Tp& x) {return x * x;} /* sqr */

inline bool connected()
{
    static const int SIZE = 0x3ffff;
    static int q[SIZE + 1];
    static bool marked[maxN];
    memset(marked, 0, sizeof marked);
    int f = 0, r = 0, u, v;
    for (q[r++] = 0; f - r;)
    for (marked[u = q[f++]] = true, f &= SIZE, v = 0; v < n; ++v)
        if (mp[u][v] < INF && !marked[v]) marked[q[r++] = v] = true, r &= SIZE;
    for (int i = 0; i < n; ++i)
        if (!marked[i]) return false;
    return true;
} /* connected */

inline int loop()
{
    pre[root = 0] = 0;
    for (int i = 0; i < n; ++i)
    if (!del[i] && i != root)
    {
        mp[i][i] = INF; pre[i] = i;
        for (int j = 0; j < n; ++j)
        if (!del[j] && mp[j][i] < mp[pre[i]][i])
            pre[i] = j;
    } /* if */
    for (int i = 0; i < n; ++i) if (!del[i] && i != root)
    {
        static bool vis[maxN];
        memset(vis, 0, sizeof vis);
        int j = i;
        for (; !vis[j]; j = pre[j]) vis[j] = true;
        if (j == root) continue;
        else return j;
    } /* if */
    return -1;
} /* loop */

inline void update(int t, double& ans)
{
    ans += mp[pre[t]][t];
    for (int i = pre[t]; i != t; i = pre[i])
        ans += mp[pre[i]][i], del[i] = true;
    for (int i = 0; i < n; ++i)
    if (!del[i] && mp[i][t] < INF)
        mp[i][t] -= mp[pre[t]][t];
    for (int j = pre[t]; j != t; j = pre[j])
    for (int i = 0; i < n; ++i)
    if (!del[i])
    {
        if (mp[i][j] < INF)
            gmin(mp[i][t], mp[i][j] - mp[pre[j]][j]);
        if (mp[j][i] < INF) gmin(mp[t][i], mp[j][i]);
    } /* for */
    return;
} /* update */

inline double solve()
{
    memset(del, 0, sizeof del);
    double ans = 0; int j;
    while (~(j = loop())) update(j, ans);
    for (int i = 0; i < n; ++i)
    if (!del[i] && i != root)
        ans += mp[pre[i]][i];
    return ans;
} /* solve */

int main()
{
    freopen("network.in" , "r", stdin );
    freopen("network.out", "w", stdout);
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            mp[i][j] = INF;
        for (int i = 0; i < n; ++i)
            scanf("%lf%lf", x + i, y + i);
        while (m--)
        {
            int u, v; scanf("%d%d", &u, &v); --u, --v;
            mp[u][v] = sqrt(sqr(x[u] - x[v]) + sqr(y[u] - y[v]));
        } /* while */
        if (!connected()) puts("poor snoopy");
        else printf("%.2lf\n", solve());
    } /* while */
    return 0;
} /* main */

/*

最小树形图模板题，不多说。

*/

tju2248 Channel Design

/**********************************\
 * @prob: tju2248 Channel Design  *
 * @auth: Wang Junji              *
 * @stat: Accepted.               *
 * @date: June. 25th, 2012        *
 * @memo: 最小树形图                *
\**********************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 110, maxM = 10010, INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, d;
    Edge(int u = 0, int v = 0, int d = 0): u(u), v(v), d(d) {} /* Edge */
} edge[maxM];
int n, m;

int Directed_MST(int root, int n, int m)
{
    int res = 0;
    for (;;)
    {
        static int In[maxN], pre[maxN], ID[maxN], vis[maxN];
        memset(In, 0x3f, sizeof In);
        for (int j = 0; j < m; ++j)
        {
            int u = edge[j].u, v = edge[j].v, d = edge[j].d;
            if (u != v && d < In[v]) In[v] = d, pre[v] = u;
        } /* for */
        for (int i = 0; i < n; ++i)
        if (i != root && In[i] == INF)
            return -1;
        memset(vis, 0xff, sizeof vis);
        memset(ID , 0xff, sizeof ID );
        int cnt_v = 0;
        for (int i = 0; i < n; ++i) if (i != root)
        {
            res += In[i]; int u = i;
            for (; vis[u] != i && ID[u] == -1 && u != root; u = pre[u])
                vis[u] = i;
            if (u != root && ID[u] == -1)
            {
                for (int v = pre[u]; v != u; v = pre[v])
                    ID[v] = cnt_v;
                ID[u] = cnt_v++;
            } /* if */
        } /* if */
        if (!cnt_v) break;
        for (int i = 0; i < n; ++i) if (ID[i] == -1) ID[i] = cnt_v++;
        for (int j = 0; j < m; ++j)
        {
            int v = edge[j].v;
            edge[j].u = ID[edge[j].u];
            edge[j].v = ID[edge[j].v];
            if (edge[j].u != edge[j].v)
                edge[j].d -= In[v];
        } /* for */
        n = cnt_v;
        root = ID[root];
    } /* for */
    return res;
} /* Directed_MST */

int main()
{
    freopen("design.in" , "r", stdin );
    freopen("design.out", "w", stdout);
    while (~scanf("%d%d", &n, &m) && (n || m))
    {
        int cnt_e = 0;
        while (m--)
        {
            int u, v, d; scanf("%d%d%d", &u, &v, &d);
            edge[cnt_e++] = Edge(--u, --v, d);
        } /* while */
        int ans = Directed_MST(0, n, cnt_e);
        if (ans < 0) puts("impossible");
        else printf("%d\n", ans);
    } /* while */
    return 0;
} /* main */

/*

最小树形图模板题，不多说。

*/

UVa11183 Teen Girl Squad

/************************************\
 * @prob: UVa11183 Teen Girl Squad  *
 * @auth: Wang Junji                *
 * @stat: Accepted.                 *
 * @date: June. 25th, 2012          *
 * @memo: 最小树形图                 *
\************************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 1010, maxM = 40010, INF = 0x3f3f3f3f;
struct Edge {int u, v, d;} edge[maxM];
int n, m, T;

int Directed_MST(int root, int n, int m)
{
    int res = 0;
    for (;;)
    {
        static int In[maxN], pre[maxN], ID[maxN], vis[maxN];
        memset(In, 0x3f, sizeof In);
        for (int j = 0; j < m; ++j)
        {
            int u = edge[j].u, v = edge[j].v, d = edge[j].d;
            if (u != v && d < In[v]) In[v] = d, pre[v] = u;
        } /* for */
        for (int i = 0; i < n; ++i)
        if (i != root && In[i] == INF)
            return -1;
        memset(ID , 0xff, sizeof ID );
        memset(vis, 0xff, sizeof vis);
        int cnt_v = 0;
        for (int i = 0; i < n; ++i) if (i != root)
        {
            res += In[i]; int u = i;
            for (; vis[u] != i && ID[u] == -1 && u != root; u = pre[u])
                vis[u] = i;
            if (ID[u] == -1 && u != root)
            {
                for (int v = pre[u]; v != u; v = pre[v])
                    ID[v] = cnt_v;
                ID[u] = cnt_v++;
            } /* if */
        } /* if */
        if (!cnt_v) break;
        for (int i = 0; i < n; ++i) if (ID[i] == -1) ID[i] = cnt_v++;
        for (int j = 0; j < m; ++j)
        {
            int v = edge[j].v;
            if ((edge[j].u = ID[edge[j].u]) != (edge[j].v = ID[edge[j].v]))
                edge[j].d -= In[v];
        } /* for */
        root = ID[root];
        n = cnt_v;
    } /* for */
    return res;
} /* Directed_MST */

int main()
{
    freopen("girl.in" , "r", stdin );
    freopen("girl.out", "w", stdout);
    for (scanf("%d", &T); T--;)
    {
        scanf("%d%d", &n, &m);
        for (int i = 0; i < m; ++i)
            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].d);
        static int Case = 0;
        printf("Case #%d: ", ++Case);
        int ans = Directed_MST(0, n, m);
        if (ans < 0) puts("Possums!");
        else printf("%d\n", ans);
    } /* for */
    return 0;
} /* main */

/*

最小树形图模板题，不多说。

*/
无定根：

hdu2121 Ice_cream’s world II

/****************************************\
 * @prob: hdu2121 Ice_cream’s world II  *
 * @auth: Wang Junji                    *
 * @stat: Accepted.                     *
 * @date: June. 25th, 2012              *
 * @memo: 最小树形图                     *
\****************************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 1010, maxM = 11010;
typedef long long int64;
int64 INF = 0x3f3f3f3f3f3f3f3fLL;
struct Edge {int u, v; int64 d;} edge[maxM];
int n, m;

int64 Directed_MST(int root, int n, int m, int& root_id)
{
    int64 res = 0;
    for (;;)
    {
        static int pre[maxN], ID[maxN], vis[maxN];
        static int64 In[maxN];
        memset(In, 0x3f, sizeof In);
        for (int j = 0; j < m; ++j)
        {
            int u = edge[j].u, v = edge[j].v;
            int64 d = edge[j].d;
            if (u != v && d < In[v]) //!!
            {
                In[v] = d, pre[v] = u;
                if (u == root) root_id = j;
            } /* if */
        } /* for */
        for (int i = 0; i < n; ++i)
        if (i != root && In[i] == INF)
            return -1;
        memset(ID , 0xff, sizeof ID );
        memset(vis, 0xff, sizeof vis);
        int cnt_v = 0;
        for (int i = 0; i < n; ++i) if (i != root)
        {
            res += In[i]; int u = i;
            for (; vis[u] != i && ID[u] == -1 && u != root; u = pre[u])
                vis[u] = i;
            if (ID[u] == -1 && u != root)
            {
                for (int v = pre[u]; v != u; v = pre[v])
                    ID[v] = cnt_v;
                ID[u] = cnt_v++;
            } /* if */
        } /* if */
        if (!cnt_v) break;
        for (int i = 0; i < n; ++i) if (ID[i] == -1) ID[i] = cnt_v++;
        for (int j = 0; j < m; ++j)
        {
            int v = edge[j].v;
            if ((edge[j].u = ID[edge[j].u]) != (edge[j].v = ID[edge[j].v]))
                edge[j].d -= In[v];
        } /* for */
        root = ID[root]; n = cnt_v;
    } /* for */
    return res;
} /* Directed_MST */

int main()
{
    freopen("Ice_cream.in" , "r", stdin );
    freopen("Ice_cream.out", "w", stdout);
    while (~scanf("%d%d", &n, &m))
    {
        int64 sum_d = 0;
        for (int i = 0; i < m; ++i)
            scanf("%d%d%lld", &edge[i].u, &edge[i].v, &edge[i].d), sum_d += edge[i].d;
        ++sum_d;
        int cnt_e = m, root_id = 0;
        for (int i = 0; i < n; ++i)
            edge[cnt_e].u = n, edge[cnt_e].v = i, edge[cnt_e++].d = sum_d;
        int64 ans = Directed_MST(n, n + 1, cnt_e, root_id) - sum_d;
        if (ans < 0 || ans >= sum_d) puts("impossible\n");
        else printf("%lld %d\n\n", ans, root_id - m);
    } /* while */
    return 0;
} /* main */

/*

无定根的最小树形图。
只需要加一个虚拟根，到所有点的权值恰好比所有原边权值之和略大（这样保证虚拟根只会与其中一个点连边），并且再记录一下根的位置就可以了（如果一个点的入边为虚拟根，那么这个点为“真实的”根）。

要用long long类型。


*/
（这并不是一道真正意义上的最小树形图：）

hdu3072 Intelligence System

/***************************************\
 * @prob: hdu3072 Intelligence System  *
 * @auth: Wang Junji                   *
 * @stat: Accepted.                    *
 * @date: June. 25th, 2012             *
 * @memo: 强连通分量                    *
\***************************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

typedef long long int64;
const int maxN = 50010, maxM = 100010;
const int64 INF = 0x3f3f3f3f3f3f3f3fLL;

struct Edge
{
    int u, v; int64 d; Edge* next; Edge() {} /* Edge */
    Edge(int u, int v, int64 d, Edge* next):
        u(u), v(v), d(d), next(next) {}
    /* Edge */
} __edge[maxM], *edge[maxN], *tot = __edge; 
bool marked[maxN];
int Low[maxN], DFN[maxN], sta[maxN];
int ID[maxN], n, m, Bcnt, Index, top;

template <typename _Tp>
inline _Tp& gmax(_Tp& a, const _Tp& b)
{return a > b ? a : (a = b);}
/* gmax */

template <typename _Tp>
inline _Tp& gmin(_Tp& a, const _Tp& b)
{return a < b ? a : (a = b);}
/* gmin */

void Tarjan(int u)
{
    DFN[u] = Low[u] = Index++;
    marked[sta[top++] = u] = true;
    for (Edge* p = edge[u]; p; p = p -> next)
    {
        if (DFN[p -> v] == -1) Tarjan(p -> v), gmin(Low[u], Low[p -> v]);
        else if (marked[p -> v])               gmin(Low[u], DFN[p -> v]);
    } /* for */
    if (Low[u] == DFN[u])
    {
        int tmp = u;
        do
            ID[tmp = sta[--top]] = Bcnt, marked[tmp] = false;
        while (tmp != u);
        ++Bcnt;
    } /* if */
    return;
} /* Tarjan */

int main()
{
    freopen("Intelligence.in" , "r", stdin );
    freopen("Intelligence.out", "w", stdout);
    while (~scanf("%d%d", &n, &m))
    {
        memset(edge, 0, sizeof edge); tot = __edge;
        while (m--)
        {
            int u, v; int64 d;
            scanf("%d%d%lld", &u, &v, &d);
            edge[u] = new (tot++) Edge(u, v, d, edge[u]);
        } /* while */
        memset(ID    , 0xff, sizeof ID    );
        memset(DFN   , 0xff, sizeof DFN   );
        memset(Low   , 0xff, sizeof Low   );
        memset(marked, 0   , sizeof marked);
        Bcnt = top = Index = 0;
        Tarjan(0);
        static int64 In[maxN];
        memset(In, 0x3f, sizeof In);
        for (Edge* p = __edge; p != tot; ++p)
        if (ID[p -> u] != ID[p -> v])
            gmin(In[ID[p -> v]], p -> d);
        In[ID[0]] = 0;
        int64 ans = 0;
        for (int i = 0; i < Bcnt; ++i) ans += In[i];
        printf("%lld\n", ans);
    } /* while */
    return 0;
} /* main */

/*

缩点，然后将所有最小入边相加。

*/

稍加变形：

hdu4009 Transfer water

/**********************************\
 * @prob: hdu4009 Transfer water  *
 * @auth: Wang Junji              *
 * @stat: Accepted.               *
 * @date: June. 25th, 2012        *
 * @memo: 最小树形图               *
\**********************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 1010, maxM = maxN * (maxN + 1), INF = 0x3f3f3f3f;

struct Edge {int u, v, d;} edge[maxM];
int x[maxN], y[maxN], z[maxN], n, m, X, Y, Z, cnt_e;

inline int dist(int i, int j)
{return std::abs(x[i] - x[j]) + std::abs(y[i] - y[j]) + std::abs(z[i] - z[j]);}

inline void Ins(int u, int v, int d)
{
    edge[cnt_e].u = u;
    edge[cnt_e].v = v;
    edge[cnt_e].d = d;
    ++cnt_e; return;
} /* Ins */

int Directed_MST(int root, int n, int m)
{
    int res = 0;
    for (;;)
    {
        static int pre[maxN], ID[maxN], vis[maxN];
        static int In[maxN];
        memset(In, 0x3f, sizeof In);
        for (int j = 0; j < m; ++j)
        {
            int u = edge[j].u, v = edge[j].v;
            int d = edge[j].d;
            if (u != v && d < In[v]) In[v] = d, pre[v] = u;
        } /* for */
        for (int i = 0; i < n; ++i)
        if (i != root && In[i] == INF)
            return -1;
        memset(ID , 0xff, sizeof ID );
        memset(vis, 0xff, sizeof vis);
        int cnt_v = 0;
        for (int i = 0; i < n; ++i) if (i != root)
        {
            res += In[i]; int u = i;
            for (; ID[u] == -1 && u != root && vis[u] != i; u = pre[u])
                vis[u] = i;
            if (u != root && ID[u] == -1) //!!
            {
                for (int v = pre[u]; v != u; v = pre[v])
                    ID[v] = cnt_v;
                ID[u] = cnt_v++;
            } /* if */
        } /* if */
        if (!cnt_v) break;
        for (int i = 0; i < n; ++i) if (ID[i] == -1) ID[i] = cnt_v++; //!!
        for (int j = 0; j < m; ++j)
        {
            int v = edge[j].v;
            if ((edge[j].u = ID[edge[j].u]) != (edge[j].v = ID[edge[j].v]))
                edge[j].d -= In[v];
        } /* for */
        n = cnt_v;
        root = ID[root];
    } /* for */
    return res;
} /* Directed_MST */

int main()
{
    freopen("Transfer.in" , "r", stdin );
    freopen("Transfer.out", "w", stdout);
    while (~scanf("%d%d%d%d", &n, &X, &Y, &Z) && (n || X || Y || Z))
    {
        for (int i = 0; i < n; ++i)
            scanf("%d%d%d", x + i, y + i, z + i);
        cnt_e = 0;
        for (int i = 0, K, j; i < n; ++i)
        {
            scanf("%d", &K);
            while (K--)
            {
                scanf("%d", &j); --j;
                Ins(i, j, Y * dist(i, j) + (z[i] < z[j] ? Z : 0));
            } /* while */
        } /* for */
        for (int i = 0; i < n; ++i) Ins(n, i, z[i] * X);
        int ans = Directed_MST(n, n + 1, cnt_e);
        if (ans < 0) puts("poor XiaoA");
        else printf("%d\n", ans);
    } /* while */
    return 0;
} /* main */

/*

新建虚拟根，虚拟根到每个点的权值为该点自建水库的费用。
注意当i的海拔低于j时，仍然要算上Y的基本费用（Z为附加费用，而不是全部费用）。

*/

Whjpji
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小树形图 Tarjan的DMST算法
q779的博客
03-27 2101
这篇是Tarjan的DMST算法哦！ qwq
最小树形图-朱刘算法详解 +例题解析
pursuit的博客
08-17 5489
文章目录最小树形图定义和最小生成树的区别朱刘算法思想步骤流程展示算法实现例题 最小树形图 定义 对于有向图G=(V,E)G = (V,E)G=(V,E)，其中具有如下性质 GGG中不包含有向环。 存在一个根结点uuu，它不是任何弧的终点，而且uuu的其他顶点都恰好是唯一的一条弧的终点。 那么则称GGG是以uuu为根的树形图。 更笼统的讲，实际上就是有一颗不存在有向环的有向树，且除根结点uuu外的每个顶点都只有一条入边。 而最小树形图则是权值最小的那个。 这是一个最小树形图的例子。 和最小生成树的区别
最小树形图（朱-刘算法）
Izayoi_w的博客
08-13 748
概念导入：最小树形图可以简单的理解为树枝有方向的最小生成树，加上了方向的限制，使得得到它要稍微麻烦一点，解决这个问题的算法是朱永津与刘振宏在上世纪60年代提出的朱-刘算法（难得的中国人的算法）。 定义：设G = (V,E)是一个有向图，它具有下述性质： 1. G中不包含有向环；　 2. 存在一个顶点vi，它不是任何弧的终点，而V中的其它顶点都恰好是唯一的一条弧的终点； 则...
【算法精讲】最小树形图 (两份讲解 配套例题)
Suprit's blog
06-14 1555
其一 概述 最小树形图, 简而言之就是求有向带权图的最小生成树. 官方定义是这样的: 最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振宏提出的复杂度为O(VE)的算法：朱、刘算法。 今天我们就来浅谈一下最小树形图的问题。 最小树形图, 简而言之就是求有向带权图的最小生成树....
最小树形图/朱刘算法
qq_52406324的博客
03-06 309
最小树形图/朱刘算法 最小生成树是具有最小权值的无向树，最小树形图则是具有最小权值的有向树 算法思想和kruskal类似，也是采用贪心的思想，每次取用权值最小的那条边，只是由于有向图边权带有方向，有一些特殊情况需要我们去解决。 1.是否存在最小树形图；我们知道在无向图中（不考虑负权），只要所有点都是连通的，就一定存在最小生成树，在有向图中也是一样的，每个点都必须存在一条连向它的边，即不存在某个点，它的入度为0 ，如果有某个点入度为0，那就不存在树形图(不连通)，更不存在最小树形图。 2.每次取权值最小的边，
二叉排序树与平衡二叉树的实现
12-26
平衡二叉排序树的在平衡因子绝对值等于2时开始调整到绝对值为1或0，在平衡因子绝对值为2时，二叉排序树会出现四种不同的情况的树形，因此这时需要分别单独讨论来降低平衡因子。 1.2.7 平衡二叉树的调整方法 　平衡...
数据结构与算法复习.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构和算法的复习.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
计算机基础应用复习题及答案.docx
06-04
树形结构 B.层次结构 C. 网状结构 D. 嵌套结构 2．在"资源管理器"中选择多个不连续的文件用（ D ）键。 +Alt +Ctrl 3．在Windows下，当一个文学艺术用程序窗口被最小化后，该应用程序（C ）。 A.终止运行 B.暂停运行...
《计算机操作系统》期末复习指导
12-30
对考试很有帮助的.......... 《计算机操作系统》期末复习指导 第一章 计算机操作系统概述 ...（1）操作系统文件的目录组织是一个树形结构，从根结点到叶子称为文件的全路径名，文件可以由其全路径名唯一确定...
最小树与最小树形图
06-11
它是关于最小树与最小树形图 方面的相关资料。。。
最小树形图_树形图权_最小树形图虚根_
10-02
输出一个图中最佳源点的最小树形图权值和的一个程序
最小树形图（朱刘算法）
Z7784562的博客
05-17 449
思路： 最小树形图就是在有向图中，以一个点为根的有向生成树，并且边权值和最小。 思路大体上是贪心。 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 5623
【概述】 最小树形图，就是给出一个带权有向图，从中指定一个特殊的结点 root，求一棵以 root 为根的有向生成树 T，且使得 T 中所有边权值最小。 简单来说，最小树形图就是有向图的最小生成树。 【朱刘算法】 1.过程 简单来说，朱刘算法分为四个过程： 1）求最短弧集合 E 2）判断集合 E 中有没有有向环，如果有转步骤 3，否则转 4 3）收缩点，把有向环收缩成一个点，并且对...
最小树形图
Kona的博客
05-14 193
模板题：poj3164 定义：一个有向图，存在从某个点开始的到达所有的的一个最小生成树，则它就是最小树形图。 朱-刘算法的大概过程如下： 1、找到除了root以为其他点的权值最小的入边。用In[i]记录 2、如果出现除了root以外存在其他孤立的点，则不存在最小树形图。 3、找到图中所有的环，并对环进行缩点，重新编号。 4、更新其他点到环上的点的距离         假设有重新编号之...
最小树形图——朱刘算法
Baiyi_destroyer的博客
08-09 294
一、相关定义 定义：设G = (V,E)是一个有向图，它具有下述性质： G中不包含有向环；　 存在一个顶点vi，它不是任何弧的终点，而V中的其它顶点都恰好是唯一的一条弧的终点，则称 G是以vi为根的树形图。 最小树形图就是有向图G = (V, E)中以vi为根的树形图中权值和最小的那一个。 另一种说法：最小树形图，就是给有向带权图一个特殊的点root，求一棵以root为根节点的树使得该树的...
Hdu 2121 Ice_cream’s world II 无根最小树形图
e的专栏
07-15 640
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2121
动态完全图最小生成树
09-25
动态完全图最小生成树是指在一个无向完全图中，每次添加或删除一条边后，重新计算生成树的过程。其中，最小生成树是指在无向图中选择权值最小的边，使得图中的所有顶点都连通，并且不形成环。 对于动态完全图最小...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值