各种奇怪的生成树问题

最新推荐文章于 2022-11-17 15:08:14 发布
最新推荐文章于 2022-11-17 15:08:14 发布
阅读量1k 收藏 1
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/praesidio/article/details/38691515
版权

各种奇怪的生成树问题

最近做了5道生成树问题，现在总结一下。

  • 求最大边最小边差值最小的生成树
  • 次小生成树
  • 有向图生成树(最小树形图)
  • 最优比率生成树
  • 顶点度数有限制的MST

1.求最大边最小边差值最小的生成树

题目

POJ3522

求一颗生成树，让最大边最小边差值最小，kruskal。
将边排序后，从最小的开始依次枚举。很暴力的做法，没想出更好的方法，百度了一下，差不多都是这个暴力的想法。

主要代码



const int maxn = 110;

struct Edge {
    int from,to,len;
};

int n , m;
int father[maxn];

Edge edge[maxn * maxn ];

bool cmp ( Edge a , Edge b ) {
    return a.len < b.len ;
}

int find ( int x ) {
    return ( x == father[x] ) ? x : father[x] = find (father[x] );
}

int main()
{
    while ( ~scanf("%d%d",&n,&m) && n+m ) {

        for ( int i = 0 ; i < m ; i++ ) {
            scanf("%d%d%d",&edge[i*2].from,&edge[i*2].to,&edge[i*2].len);
            edge[i*2+1].from = edge[i*2].to;
            edge[i*2+1].to = edge[i*2].from;
            edge[i*2+1].len = edge[i*2].len;
        }

        m *= 2;
        sort ( edge , edge + m , cmp );

        int st = 0 , ans = -1;
        while ( st + n - 2 < m ) {

            for ( int i = 1 ; i <= n ; i++ ) father[i] = i;

            int cnt = 0 , maxlen = 0 , flag = 0;
            for ( int i = st ; i < m ; i++ ) {
                if ( cnt == n - 1 ) {
                    flag = 1;
                    break;
                }
                Edge e = edge[i];
                int u = find(e.from);
                int v = find(e.to);
                if ( u != v ) {
                    maxlen = max ( ans , e.len );
                    cnt++;
                    father[u] = v;
                }
            }
            if ( flag )
            ans = (ans==-1) ? maxlen-edge[st].len : min ( ans , maxlen-edge[st].len);
            st++;
        }

        printf("%d\n",ans);
    }
    return 0;
}

2.次小生成树

题目

POJ1679

判断MST是否唯一。可以求次小生成树，然后判断次小和最小是否相等。当然，不用求出次小，在求次小的过程中，就可以判断出是否唯一。

方法有两种：

  • 先求出MST。然后枚举MST的每一条边，每次删掉一条边，求MST，这些MST中的最小值，就是次小生成树
  • 先求出MST。然后枚举非MST上的一条边，加上这条边一定会形成一个环，然后找到这个环上除了加上的这条边的最大边（就是这个边的两个端点在MST上的路径中的最大边），减去这个最大边，加上新边，就是一颗新树。所有新树中的最小值，就是次小生成树。最大边可以用BFS或DFS预处理。

我采用的是第二种，写的很挫。

主要代码


const int maxn = 110;

struct Edge {
    int id;
    int from , to , len;
    int flag;
    Edge() {flag = 0;}
    Edge( int from , int to , int len ) :
        from(from),to(to),len(len) { flag = 0; }
    bool operator < ( const Edge& rhs ) const {
        return len > rhs.len ;
    }
};

vector  edges;
vector  G[maxn];
int n,m;
int vis[maxn] , dis[maxn] , nxt[maxn] , nxtlen[maxn];
vector  mst[maxn];
int f[maxn][maxn];

void AddEdge ( int x , int y , int z ) {
    edges.pb( Edge(x,y,z) );
    int m = sz(edges);
    edges[m-1].id = m-1;
    edges[m-1].flag = 0;
    G[x].pb( sz(edges) - 1 );
}

void init() 
{
    scanf("%d%d",&n,&m);
    for ( int i = 1 ; i <= n ; i++ ) G[i].clear();
    for ( int i = 1 ; i <= n ; i++ ) mst[i].clear();
    edges.clear();
    for ( int i = 1 ; i <= m ; i++ ) {
        int x , y , z ;
        scanf("%d%d%d",&x,&y,&z);
        AddEdge ( x , y , z );
        AddEdge ( y , x , z );
    }
}

int MST() {
    priority_queue  q;
    int ans = 0;
    clr(vis);
    for ( int i = 0 ; i < sz(G[1]) ; i++ ) {
        Edge& e = edges[G[1][i]] ; 
        int v = e.to;
        if ( dis[v] > e.len ) {
            dis[v] = e.len;
            Edge ee;
            ee.from = 1; ee.to = v ; ee.len = dis[v] ; ee.id = e.id;
            q.push(ee);
        }
    }
    vis[1] = 1;
    while ( !q.empty() ) {
        Edge e = q.top(); q.pop();
        int u = e.to;
        if ( vis[u] ) continue;
        vis[u] = 1;
        ans += dis[u];
        e.flag = 1;

        mst[e.from].pb( mp ( e.to , e.len ) );
        mst[e.to].pb( mp ( e.from , e.len ));

        edges[e.id].flag = 1;
        edges[e.id^1].flag = 1;
        for ( int i = 0 ; i < sz ( G[u] ) ; i++ ) {
            Edge& e = edges[ G[u][i] ];
            if ( !vis[e.to] && dis[e.to] > e.len ) {
                dis[e.to] = e.len;
                Edge ee;
                ee.from = u ; ee.to = e.to; ee.len = e.len ; ee.id = e.id; 
                q.push(ee);
            }
        }
    }
    return ans;
}

void BFS ( int s ) {
    queue  q;
    clr(vis);
    q.push(s);
    vis[s] = 1;
    while ( !q.empty() ) {
        int u = q.front(); q.pop();
        for ( int i = 0 ; i < sz(mst[u]) ; i++ ) {
            int v = mst[u][i].first;
            f[s][v] = max ( f[s][u] , mst[u][i].second );
            if ( !vis[v] ) { q.push(v); vis[v] = 1; }
        }
    }
}

int main()
{
//    freopen("a.in","r",stdin);

    int T;
    scanf("%d",&T);
    while ( T-- ) {
        init();
        memset(nxt,-1,sizeof(nxt));
        memset(nxtlen,-1,sizeof(nxtlen));
        for ( int i = 1 ; i <= n ; i++ ) dis[i] = inf;
        int ans = MST();

        memset( f , -1 , sizeof(f) );

        for ( int i = 1 ; i <= n ; i++ ) BFS(i);

        for ( int i = 1 ; i <= n ; i++ ) 
            for ( int j = 1 ; j <= n ; j++ ) 
                if ( f[i][j] != -1 ) f[j][i] = f[i][j];



        int flag = 0;
        for ( int i = 0 ; i < sz(edges) ; i++ ) {
            Edge& e = edges[i];
            if ( e.flag == 0 && e.len == f[e.from][e.to] ) {
                flag = 1;
                break;
            }
        }
        if ( flag ) 
            printf("Not Unique!\n");
        else 
            printf("%d\n",ans);
    }
    return 0;
}

3.有向图生成树（最小树形图）

题目

POJ3164

最小树形图的模板题。我直接用了模板。
关于算法的讲解，请点这里

主要代码

  • 邻接矩阵

const int VN = 105;  
const int INF = 0x7fffffff;   
template  
class Directed_MST{  
public:  
    void init(int _n){  
        n=_n;   
        ans = 0;  
        memset(vis, 0, sizeof(vis));  
        memset(inc, 0, sizeof(inc));  
        for(int i=0; i <= n; ++i){  
            w[i][i] = INF;  
            for(int j=i+1; j<=n; ++j)  
                w[i][j]=w[j][i]=INF;  
        }  
    }  
    void insert(int u, int v, Type _w){  
        if(w[u][v]>_w) w[u][v] = _w;  
    }  
    Type directed_mst(int u){  
        //==  步骤1： 判断能否形成最小树形图，直接dfs遍历   
        dfs(u);  
        for(int i=1; i <= n; ++i)  
            if(!vis[i]) { return -1; }  

        //== 如果可以形成最小树形图，继续  
        memset(vis, 0, sizeof(vis));  
        while(true){  
            //== 1. 找最小前驱边    
            for(int i=1; i <= n; ++i)if(i!=u&&!inc[i]){  
                w[i][i]=INF, pre[i] = i;  
                for(int j=1; j<=n; ++j)if(!inc[j] && w[j][i]<w[pre[i]][i]){ pre[i]="j;" }="" =="2.判断是否有环" int="" i;="" for(i="1;" i="" <="n;" ++i)if(i!="u&&!inc[i]){" j="i," cnt="0;" while(j!="u" &&="" pre[j]!="i" ++cnt;="" if(j="=u" ||="">n) continue; //没找到  
                break;  
            }  

            //== 没有找到环,得到答案                
            if(i>n){    
                for(int i=1; i <= n; ++i)if(i!=u && !inc[i]) ans+=w[pre[i]][i];  
                return ans;  
            }  
            //==  有环，进行收缩    
            int j=i;  
            memset(vis, 0, sizeof(vis));  
            do{  
                ans += w[pre[j]][j], j=pre[j], vis[j]=inc[j]=true;  
            }while(j!=i);  
            inc[i] = false; // 环缩成了点i，点i仍然存在  

            //==  收缩  
            for(int k=1; k <= n; ++k)if(vis[k]){ // 在环中点点  
                for(int j=1; j <= n; ++j)if(!vis[j]){  // 不在环中的点  
                    if(w[i][j] > w[k][j]) w[i][j] = w[k][j];  
                    if(w[j][k] < INF && w[j][k]-w[pre[k]][k] < w[j][i])  
                        w[j][i] = w[j][k] - w[pre[k]][k];  
                }    
            }  
        }  
        return ans;        
    }  
private:  
    // 从根结点遍历一遍，判断是否存在最小树形图  
    void dfs(int u){  
        vis[u] = true;  
        for(int i=1; i <= n; ++i)if(!vis[i]&&w[u][i] < INF){  
            dfs(i);  
        }  
    }  
private:  
    Type ans;         // 所求答案  
    int n;            // 结点个数  
    int pre[VN];      // 权值最小的前驱边  
    bool vis[VN];     // 是在环中还是在环外  
    bool inc[VN];     // 该点是否被删除了（收缩）  
    Type w[VN][VN];   // 图  
};
  • 邻接表

struct node  
{  
    int u, v;  
    type w;  
}edge[MAXN * MAXN];  
int pre[MAXN], id[MAXN], vis[MAXN], n, m;  
type in[MAXN];    
type Directed_MST(int root, int V, int E)  
{  
    type ret = 0;  
    while(true)  
    {  
        //1.找最小入边  
        for(int i = 0; i < V; i++)  
           in[i] = INF;  
        for(int i = 0; i < E; i++)  
        {  
            int u = edge[i].u;  
            int v = edge[i].v;  
            if(edge[i].w < in[v] && u != v)  
              {pre[v] = u; in[v] = edge[i].w;}  
        }  
        for(int i = 0; i < V; i++)  
        {  
            if(i == root) continue;  
            if(in[i] == INF) return -1;//除了根以外有点没有入边,则根无法到达它  
        }  
        //2.找环  
        int cnt = 0;  
        memset(id, -1, sizeof(id));  
        memset(vis, -1, sizeof(vis));  
        in[root] = 0;  
        for(int i = 0; i < V; i++) //标记每个环  
        {  
            ret += in[i];  
            int v = i;  
            while(vis[v] != i && id[v] == -1 && v != root)  //每个点寻找其前序点，要么最终寻找至根部，要么找到一个环  
            {  
                vis[v] = i;  
                v = pre[v];  
            }  
            if(v != root && id[v] == -1)//缩点  
            {  
                for(int u = pre[v]; u != v; u = pre[u])   
                    id[u] = cnt;  
                id[v] = cnt++;  
            }  
        }  
        if(cnt == 0) break; //无环   则break  
        for(int i = 0; i < V; i++)  
            if(id[i] == -1) id[i] = cnt++;  
        //3.建立新图  
        for(int i = 0; i < E; i++)  
        {  
            int u = edge[i].u;  
            int v = edge[i].v;  
            edge[i].u = id[u];  
            edge[i].v = id[v];  
            if(id[u] != id[v]) edge[i].w -= in[v];  
        }  
        V = cnt;  
        root = id[root];  
    }  
    return ret;  
}

4.最优比率生成树

题目

POJ2728

求最优比例生成树。
关于分数规划，可以看论文 《最小割在信息学竞赛中的应用》 ，还有黑书
有两种方法，一种是二分，一种是Dinkelbach算法。
此题如果用二分，生成树要用O(n)的算法才不会超时，所以用Dinkelbach了。

主要代码

  • 二分 （TLE）

const int maxn = 1010;

struct Edge {
    int from , to;
    double b,c;
    double d;
    Edge(){}
    Edge( int u , int v , double b , double c ) :
        from(u) , to(v) , b(b) , c(c) {}
    bool operator < ( const Edge& rhs ) const {
        return d > rhs.d;
    }
};
int x[maxn] , y[maxn] , z[maxn];
vector  edges;
vector  G[maxn];
double dis[maxn];
int n;

double dist ( int u , int v ) {
    return sqrt( sqr ( x[u] - x[v] ) + sqr ( y[u] - y[v] ) );
}

void AddEdge ( int u  , int v ) {
    edges.pb( Edge( u , v , dist(u,v) , fabs(z[u]-z[v]) ) );
    int m = sz(edges);
    G[u].pb(m-1);
}

double MST ( double l ) {
    for ( int i = 0 ; i < sz(edges) ; i++ ) edges[i].d = edges[i].c - edges[i].b * l;
    priority_queue  q;
    double ans = 0;
    int vis[maxn];
    clr(vis);
    for ( int i = 0 ; i < sz ( G[1] ) ; i++ ) {
        Edge& e = edges[ G[1][i] ];
        int v = e.to;
        if ( dis[v] > e.d ) {
            dis[v] = e.d;
            Edge ee;
            ee.from = 1; ee.to = v ; ee.d = e.d;
            q.push(ee);
        }
    }
    vis[1] = 1;
    while ( !q.empty() ) {
        Edge e = q.top() ; q.pop();
        int u = e.to;
        if ( vis[u] ) continue;
        vis[u] = 1;
        ans += dis[u];
        for ( int i = 0 ; i < sz ( G[u] ) ; i++ ) {
            Edge& e = edges[ G[u][i] ] ;
            int v = e.to;
            if ( !vis[v] && dis[v] > e.d ) {
                dis[v] = e.d;
                Edge ee;
                ee.from = 1; ee.to = v ; ee.d = e.d;
                q.push(ee);
            }
        }
    }
    return ans;
}
int init() 
{
    scanf("%d",&n);
    if ( n == 0 ) return 0;
    for ( int i = 1 ; i <= n ; i++ ) scanf("%d%d%d",&x[i],&y[i],&z[i]) , G[i].clear();
    for ( int i = 1 ; i <= n ; i++ ) 
        for ( int j = 1 ; j <= n ; j++ ) 
            if ( i != j ) AddEdge ( i , j );
    return 1;
}

int main()
{
    while ( init() ) {

        double l = 0.0 , r = 10000.0;
        while ( l + eps < r ) {
            double mid = ( l + r ) / 2;
            for ( int i = 1 ; i <= n ; i++ ) dis[i] = inf;
            double ans = MST(mid);
            if ( ans > 0 ) l = mid;
            else r = mid;
        }
        printf("%.3lf\n",l);
    }
    return 0;
}
  • Dinkelbach (Memory: 52556 KB Time: 2407 MS 也是好悬的飘过啊）

const int maxn = 1010;

struct Edge {
    int from , to;
    double b,c;
    double d;
    Edge(){}
    Edge( int u , int v , double b , double c ) :
        from(u) , to(v) , b(b) , c(c) {}
    bool operator < ( const Edge& rhs ) const {
        return d > rhs.d;
    }
};
int x[maxn] , y[maxn] , z[maxn];
vector  edges;
vector  G[maxn];
double dis[maxn];
int n;

double dist ( int u , int v ) {
    return sqrt( sqr ( x[u] - x[v] ) + sqr ( y[u] - y[v] ) );
}

void AddEdge ( int u  , int v ) {
    edges.pb( Edge( u , v , dist(u,v) , fabs(z[u]-z[v]) ) );
    int m = sz(edges);
    G[u].pb(m-1);
}

double MST ( double l ) {
    for ( int i = 0 ; i < sz(edges) ; i++ ) edges[i].d = edges[i].c - edges[i].b * l;
    priority_queue  q;
    double ans = 0 , p = 0 , qq = 0;
    int vis[maxn];
    clr(vis);
    for ( int i = 0 ; i < sz ( G[1] ) ; i++ ) {
        Edge& e = edges[ G[1][i] ];
        int v = e.to;
        if ( dis[v] > e.d ) {
            dis[v] = e.d;
            Edge ee;
            ee.from = 1; ee.to = v ; ee.c = e.c ; ee.b = e.b; ee.d = e.d;
            q.push(ee);
        }
    }
    vis[1] = 1;
    while ( !q.empty() ) {
        Edge e = q.top() ; q.pop();
        int u = e.to;
        if ( vis[u] ) continue;
        vis[u] = 1;
        ans += dis[u];
        p += e.c;
        qq += e.b;
        for ( int i = 0 ; i < sz ( G[u] ) ; i++ ) {
            Edge& e = edges[ G[u][i] ] ;
            int v = e.to;
            if ( !vis[v] && dis[v] > e.d ) {
                dis[v] = e.d;
                Edge ee;
                ee.from = 1; ee.to = v ; ee.b =e.b; ee.c =e.c; ee.d = e.d;
                q.push(ee);
            }
        }
    }
    double ll = p/qq;
    if ( fabs ( l - ll ) > eps )  return ll;
    else {
       printf("%.3f\n",l);
       return 0;
    }
}
int init() 
{
    scanf("%d",&n);
    if ( n == 0 ) return 0;
    edges.clear();
    for ( int i = 1 ; i <= n ; i++ ) scanf("%d%d%d",&x[i],&y[i],&z[i]) , G[i].clear();
    for ( int i = 1 ; i <= n ; i++ ) 
        for ( int j = 1 ; j <= n ; j++ ) 
            if ( i != j ) AddEdge ( i , j );
    return 1;
}

int main()
{
    while ( init() ) {

        for ( int i = 1 ; i <= n ; i++ ) dis[i] = inf;
        double l = MST(0.0);
        while ( sgn(l) != 0 ) {
            for ( int i = 1 ; i <= n ; i++ ) dis[i] = inf;
            l = MST(l);
        }
    }
    return 0;
}

5.顶点度数有限制的MST

题目

POJ1639

资料可以看黑书，还有论文《最小生成树问题的拓展》

具体步骤如下：

  • 删除V0点，求最小生成森林，会得到 m 个连通分量。 求每个连通分量上距离V0最近的点。
  • 这样求得 m 度最小生成树 ，等于每个森林的和，再加上每个分量到V0的最近距离。
  • 对 生成树 进行 k-m 次 可行操作。 （若 k < m , 则无解）
  • 可行操作：枚举每一条V0出发而不在当前树上的边，记另一点为Vx。 找到所有符合条件的Vx中，length(V0,Vx) - maxcost(V0) 最小的 Vx。 连接V0和Vx ，删去maxcost的边。 得到新树，重复操作。
  • maxcost(Vx) 为Vx到V0在当前树的路径中的最大边。可以用DP预处理出来。

主要代码

这题现在还没AC。敲代码太不稳了。总是WA。

Author

  • Author : Praesidio
  • Time : 2014-8-19 22:24:47
​
__Praesidio_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
parser:一个简单的数学表达式解析器
03-20
适用于Python的数学解析器 该存储库包含一个语法分析器，用于以92行Python代码编写的形式为2*(3+4)简单数学表达式。除了可以在Python标准库中找到的依赖项之外，不使用任何依赖项。它仅出于教育目的而存在。 如何使用它 python3 compute.py '2*(3+4)' 结果应该是14 。这也许并不奇怪，但是您也可以运行 python graphviz.py '2*(3+4)' > graphviz_input dot -Tpng graphviz_input -o output.png 以获得抽象语法树的可视化表示（这需要安装 ）。 介绍 令我个人惊讶的是， 似乎，这意味着没有使用诸如类的编译器生成工具。由于几乎所有编程语言的基本构建块都是数学表达式，因此该存储库将探索为这些简单的数学表达式构建手写解析器。 这个特殊的问题一定已经被世界各地的计算机科学专业的学生解决了
9cc:小型C编译器
04-01
9cc C编译器 注意：9cc不再是一个活动项目，后继者是 。 9cc是我的 C编译器的后继产品。 在这个新项目中，我正在尝试编写易于生成的代码，这些代码在创建可生成合理有效汇编的编译器时非常容易理解。 9cc比8cc具有更多的阶段。 以下是内部结构的概述： 将输入字符串编译为抽象语法树。 在树上运行语义分析器，以将类型添加到每个树节点。 将树转换为中间代码（IR），在某种程度上类似于x86-64指令，但具有无限数量的寄存器。 将无限数量的寄存器映射到有限数量的寄存器。 从IR生成x86-64指令。 为了使代码尽可能简单，我做出了一些重要的设计选择： 与8cc一样，没有内存管理是9cc中的内存管理策略。 我们使用malloc（）分配内存，但从不调用free（）。 我知道人们发现该策略很奇怪，但这实际上是短期程序（例如编译器）的合理设计选择。 该策略极大地简化了代码，并且完
快速生成树原理
08-30
RSTP概要1_快速生成树原理介绍：生成树协议是一种二层管理协议，它通过有选择性地阻塞网络冗余链路来达到消除网络二层环路的目的，同时具备链路的备份功能。 由于生成树协议本身比较小，所以并不像路由协议那样广为人知。但是它却掌管着端口的转发大权—“小树枝抖一抖，上层协议就得另谋生路”。真实情况也确实如此，特别是在和别的协议一起运行的时候，生成树就有可能断了其他协议的报文通路，造成种种奇怪的现象。
leetcode双人赛-algorithm_021:从0到1的算法
06-30
leetcode双人赛 algorithm_021 Algorithm from 0 to 1 # Algorithm Language Author 1. python 2. python 3. python 4. python 5. python 6. python LeetCode 百题计划：我将用 2 个月时间刷完 LeetCode 上随机选择的 120 道题 （每天 2 道） 公开此 repo 以便激励自己 下面的表格用 生成 No. LeetCode # Title Link Solution Difficulty Date Done 1 528 按权重随机选择 Medium 2021/05/09 :check_mark: 2 777 在LR字符串中交换相邻字符 Medium 2021/05/09 :check_mark: 3 65 有效数字 Hard 2021/05/10 :check_mark: 4 354 俄罗斯套娃信封问题 Hard 2021/05/10 :check_mark: 5 664 奇怪的打印机 Hard 2021/05/11 :cross_mark: 6 46 全排列 Medium 2021/05/11 :check_mark: 7 96 不同的二叉搜索树 Medium 2
finite_metal:Server Mod for Planetary Annihilation，可回收金属点，而不是建筑工地
05-12
有限金属 金属斑点是可回收的，提取器的存在只是为了帮助将纤维者路由到斑点。 该mod不包括对指挥官的更改，因此您确实有基本收入可以使用。 琐事 可以设置功能回收值，这很奇怪。 您可以获得（metal_value / max_health）/ 10，再加上一些错误，这些错误取决于所使用的构建能力。 在典型情况下，树木的特征是25/25/10或25/10/10，如果大方舍入，则基本上是1种金属，而fabber误差占主导地位。 功能必须是可损坏的才能回收。 如果回收了一个金属点，则战略图标仍然存在，但您无法在其上进行构建（很少有人在回收构建时，fabber会很幸运），如果该功能被破坏，图标确实会消失。 回收率受构建速率的限制-如果由于缺乏金属而使构建速度降低，则回收率也会降低，从而使问题更加严重。 发展 生成的项目包括一个列出依赖项的package.json ，但是您需要运行npm in
生成树相关问题整理
帅比王的博客
07-14 1028
摘要： 在对最小生成树算法有一定理解后，我们对典型的最小生成树题型应该不难解决，但是对于由最小生成树模型变形而来的几种模型，我们仍需做一次总结与记录。 首先我们需要提出最小生成树几个性质，便于推导算法；然后我们将介绍6种最小生成树相关问题模型，并讨论一般解法与更优解法；其中有的解法显而易见，接受起来也很简单，但有的解法却需要从理论上逻辑严密的进行推导，构造算法并证明算法的正确性，这部分难度稍大。 ...
数据结构-图的生成树问题
Peisenli的博客
08-28 5214
一、无向图的连通分量和生成树 若图是连通的或强连通的，则从图中某一个顶点出发可以访问到图中所有顶点； 若图是非连通的或非强连通图，则需从图中多个顶点出发搜索访问。而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为每个连通分量中的顶点集。 1、生成树 深度优先搜索遍历算法及广度优先搜索遍历算法中遍历图过程中历经边的集合和顶点集合一起构成连通图的极小连通子图。它是连通图的一颗生成树。 生...
生成树相关问题
Virgil's Blog
02-18 562
生成树相关问题
生成树（STP）
weixin_62443409的博客
11-17 2299
SW3的预备端口，20S会从Blocking状态进入到Listening状态，在进入Learning状态，最终进入Forwarding状态，进行用户流量的转发。SW3的预备端口20s后会从Blocking状态进入到Listening状态，再进入Learning状态，最终进入到Forwarding状态，进行用户流量的转发。bit 3和bit2：表示端口角色，00表示未知端口，01表示替代或备份端口，10表示根端 口，11表示指定端口。1> BPDU类型，1 Byte，RST BPDU的类性质为0x02。
生成树(ST)练习专题
SarenSage的博客
06-02 985
内容包括：最小生成树、最大生成树、单度限制最小生成树 简单（没写题解）： POJ-1252 Jungle Roads POJ-2031 Building a Space Station POJ-2421 Constructing Roads POJ-1751 Highways ZOJ-1586 QS Network 目录 中等： HDU-2489 Minimal Ratio Tree(MinST + prim) HDU-4786 Fibonacci Tree(Min + Max ST)
【算法学习笔记】生成树问题探究
橘嘉禾
04-17 22
本文探究了生成树问题的相关知识。 写在前面 生成树问题是图论的重点，其中最小生成树更是最基础的入门问题。 Murabito 将会在这里记录他有关生成树的理解。此类问题众多，本文将不断更新。 问题介绍 给定一个 \(n\) 个顶点， \(m\) 条边的无向图。要求你从中选择 \(n−1\) 条边，构成一个具有特殊性质的树。 ACM 中常见的生成树包括： 最大/小生成树 次大/小生成树 生成树计数...
最小生成树的常用算法模板
放荡者的茶会
09-22 732
关于最小生成树的话，其实很早之前就接触了，但一直没有好好去了解。 最小生成树的算法没有其他算法那么复杂，算法思想比较简单，代码也比较容易。 常见的最小生成树算法由Kruskal算法和Prim算法。 1.Kruskal算法 （时间复杂度O （m log m) 算法思想： 1.建立一个并查集，每个点构成一个集合； 2.将边进行从小到大进行排序，依次扫描边edge(u,v,w); 3.如果u和v 属于同...
[图+最小生成树+模板] 三大最小生成树常用模板
Y-puyu 的博客
10-30 747
文章目录0. 前言1. 朴素 Prim 算法求最小生成树2. 堆优化 Prim 算法求最小生成树3. Kruskal 算法求最小生成树4. 总结 0. 前言 图论中最小生成树问题一般有三种算法最为常用，如下： 朴素 PrimPrimPrim 算法：代码简单，很短，非常相似于 dijkstradijkstradijkstra 算法。主要用来求解稠密图的最小生成树问题常用。时间复杂度 O(n2)O(n^2)O(n2)。 堆优化 PrimPrimPrim 算法：代码稍微复杂，稀疏图可用，但该算法并不常用。优化部
生成树故障排查
土豆123的博客
11-24 3846
一、组网概述与故障现象 汇聚两台CE6850堆叠，现新增两台华为S5720接入交换机SW05和SW06，最初SW05和SW06的双上联口做的trunk没有做链路聚合，汇聚CE6850做链路聚合允许vlan2-4094。上架后，SW06的两个上联口UP，SW05的一个接口UP，另一个接口不UP，检查配置，将SW05的双上联口已调整为链路聚合，一个接口还是不亮，后检查原因是汇聚上对应接口配置了关闭自协商开启后正常UP。汇聚CE6850上看到SW06日志有定时发起泛洪。 二、处理过程 1.display inte
生成树问题
cosx_的博客
04-03 561
最小/大生成树 学习博客 prim模板里的：if(dist[cur] >= INF) return INF; 权值最小的点没有更新，代表无法链接所有点，所以不存在 学习博客 牛客讲解 两个最小生成树(Minimum Spanning Tree, MST)算法完全等价。 如果输入邻接矩阵，一般用Prim。需要判断重边 如果输入边表，一般用Kruskal。不用判断重边 Prim算法的优势: 稠密图, 尤其是完全图. 因为在Kurscal算法中, 必须事先求出所有边的长度才能对之排序. 但是一个有5000节
算法设计与分析之最小生成树问题
W_Tortoise的博客
05-02 5916
生成树 1.一个连通图的生成树是一个极小连通子图，它含有原图中全部顶点，并且有保持图连通的最少的边。 2.生成树不唯一。 最小生成树 设G=(V,E)G=(V,E)G=(V,E)是一个无向连通网，生成树上各边的权值之和为该生成树的代价，在GGG的所有生成树中，代价最小的生成树称为最小生成树。 贪心策略 在最小生成树问题中，至少有两种合理地贪心策略： 最近顶点策略 最...
最小生成树问题的贪心算法
最新发布
11-14
最小生成树问题是指在一个带权无向连通图中，找到一棵生成树，使得所有边的权值之和最小。贪心算法是解决最小生成树问题的一种常用方法，其中Prim算法和Kruskal算法是两种常见的贪心算法。 Prim算法的基本思想是从...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值