次小生成树：

最新推荐文章于 2024-06-18 17:55:40 发布
最新推荐文章于 2024-06-18 17:55:40 发布
阅读量91 收藏
点赞数
分类专栏： 数据结构基本算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxinxin1234/article/details/98456588
版权

一、P4180 【模板】严格次小生成树[BJWC2010]：
因为是严格的，维护最大值和严格次大值就好啦。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=300100;
const ll lnf=0x3f3f3f3f3f3f3f3f;
struct node
{
    int x,y;
    ll z;
    node(){}
    node(int a,int b,ll c)
    {
        x=a,y=b,z=c;
    }
}a[maxn];

int head[maxn],ver[maxn],nt[maxn];
ll edge[maxn];
int ff[maxn],d[maxn],f[maxn][20];
ll g[maxn][20][2];
bool ha[maxn];
int tot=1;
int t;
ll max1,max2;
int n,m;

void init(int n)
{
    for(int i=1;i<=n;i++)
    {
        head[i]=d[i]=0;
        ff[i]=i;
        memset(f[i],0,sizeof(f[i]));
        memset(g[i],0,sizeof(g[i]));
    }
    memset(ha,false,sizeof(ha));
    tot=1;
    t=log2(n)+1;
}

void add(int x,int y,ll z)
{
    ver[++tot]=y,edge[tot]=z;
    nt[tot]=head[x],head[x]=tot;
}

int fi(int x)
{
    if(ff[x]!=x)
        ff[x]=fi(ff[x]);
    return ff[x];
}

bool cmp(node &a,node &b)
{
    return a.z<b.z;
}




void bfs(void)
{
    queue<int>q;
    q.push(1);
    d[1]=1;
    while(q.size())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x];i;i=nt[i])
        {
            int y=ver[i];
            ll z=edge[i];
            if(d[y]) continue;
            d[y]=d[x]+1;
            f[y][0]=x;
            g[y][0][0]=z;
            g[y][0][1]=-lnf;
            for(int j=1;j<=t;j++)
            {
                f[y][j]=f[f[y][j-1]][j-1];

                g[y][j][0]=max(g[y][j-1][0],g[f[y][j-1]][j-1][0]);
                if(g[y][j-1][0]==g[f[y][j-1]][j-1][0])
                    g[y][j][1]=max(g[y][j-1][1],g[f[y][j-1]][j-1][1]);
                else if(g[y][j-1][0]<g[f[y][j-1]][j-1][0])
                    g[y][j][1]=max(g[y][j-1][0],g[f[y][j-1]][j-1][1]);
                else if(g[y][j-1][0]>g[f[y][j-1]][j-1][0])
                    g[y][j][1]=max(g[y][j-1][1],g[f[y][j-1]][j-1][0]);

            }
            q.push(y);
        }
    }
    return ;
}


void fuck(int &y,int i)
{
    if(g[y][i][0]>max1) max2=max(max1,g[y][i][1]),max1=g[y][i][0];
    else if(g[y][i][0]<max1) max2=max(max2,g[y][i][0]);
    else max2=max(max2,g[y][i][1]);
    y=f[y][i];
}

ll lca(int x,int y,ll z)
{
    if(d[x]>d[y]) swap(x,y);
    max1=-lnf,max2=-lnf;
    for(int i=t;i>=0;i--)
        if(d[f[y][i]]>=d[x]) fuck(y,i);

    if(x==y) return (z==max1?z-max2:z-max1);

    for(int i=t;i>=0;i--)
        if(f[y][i]!=f[x][i]) fuck(x,i),fuck(y,i);

    fuck(x,0),fuck(y,0);
    return (z==max1?z-max2:z-max1);

}


int main(void)
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init(n);

        int x,y;
        ll z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%lld",&x,&y,&z);
            a[i]=node(x,y,z);
        }
        sort(a+1,a+m+1,cmp);

        int cnt=0;
        ll ans=0;
        for(int i=1;i<=m;i++)
        {
            int xx=fi(a[i].x);
            int yy=fi(a[i].y);
            if(xx==yy) continue;

            ha[i]=true;
            ff[xx]=yy;
            add(a[i].x,a[i].y,a[i].z);
            add(a[i].y,a[i].x,a[i].z);
            cnt++;ans+=a[i].z;
            if(cnt==n-1) break;
        }
        if(cnt!=n-1) printf("-1\n");

        bfs();

        ll res=lnf;
        for(int i=1;i<=m;i++)
        {
            if(ha[i]) continue;
            res=min(res,lca(a[i].x,a[i].y,a[i].z));
        }

        printf("%lld\n",res+ans);

    }
    return 0;
}

二、The Unique MST POJ - 1679 ：
这题数据范围这么小，我觉得暴力就能过啊：
删除一条边之后，再求几遍最小生成树就是了。
①：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=10010;
int f[maxn];
int n,m;
vector<int>vc;

struct node
{
    int x,y,z;
    node(){}
    node(int a,int b,int c)
    {
        x=a,y=b,z=c;
    }
}a[maxn];

bool cmp(const node &a,const node &b)
{
    return a.z<b.z;
}

int fi(int x)
{
    if(x!=f[x])
        f[x]=fi(f[x]);
    return f[x];
}


int kr(int pt)
{
    for(int i=1;i<=n;i++)
         f[i]=i;
    int cnt=0;
    int ans=0;
    for(int i=1;i<=m;i++)
    {
        if(i==pt) continue;
        int xx=fi(a[i].x);
        int yy=fi(a[i].y);
        if(xx==yy) continue;
        f[xx]=yy;
        cnt++;
        ans+=a[i].z;
        if(cnt==n-1) break;
    }
    if(cnt!=n-1) return -1;
    return ans;
}



int main(void)
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);

        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            a[i]=node(x,y,z);
        }
        sort(a+1,a+n+1,cmp);

        vc.clear();
        int cnt=0;
        int ans=0;
        for(int i=1;i<=n;i++) f[i]=i;
        for(int i=1;i<=m;i++)
        {
            int xx=fi(a[i].x);
            int yy=fi(a[i].y);
            if(xx==yy) continue;
            f[xx]=yy;
            cnt++;
            ans+=a[i].z;
            vc.push_back(i);
            if(cnt==n-1) break;
        }
        if(cnt!=n-1)
        {
            printf("Not Unique!\n");
            continue;
        }

        bool flag=false;
        for(int i=0;i<vc.size();i++)
        {
            int tt=kr(vc[i]);
            if(tt==-1) continue;
            if(tt==ans)
            {
                printf("Not Unique!\n");
                flag=true;
                break;
            }
        }

        if(!flag) printf("%d\n",ans);

    }
    return 0;
}

②：
求非严格次小生成树也能解决吧：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=300100;
const int inf=0x3f3f3f3f;
struct node
{
    int x,y;
    ll z;
    node(){}
    node(int a,int b,ll c)
    {
        x=a,y=b,z=c;
    }
}a[maxn];

int head[maxn],ver[maxn],nt[maxn],edge[maxn];
int ff[maxn],d[maxn],f[maxn][20],g[maxn][20];
bool ha[maxn];
int tot=1,t,max1,n,m;

void init(int n)
{
    for(int i=1;i<=n;i++)
    {
        head[i]=d[i]=0;
        ff[i]=i;
        memset(f[i],0,sizeof(f[i]));
        memset(g[i],0,sizeof(g[i]));
    }
    memset(ha,false,sizeof(ha));
    tot=1;
    t=log(n*1.0)/log(2.0)+1;
}

void add(int x,int y,int z)
{
    ver[++tot]=y,edge[tot]=z;
    nt[tot]=head[x],head[x]=tot;
}

int fi(int x)
{
    if(ff[x]!=x)
        ff[x]=fi(ff[x]);
    return ff[x];
}

bool cmp(const node &a,const node &b)
{
    return a.z<b.z;
}




void bfs(void)
{
    queue<int>q;
    q.push(1);
    d[1]=1;
    while(q.size())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x];i;i=nt[i])
        {
            int y=ver[i],z=edge[i];
            if(d[y]) continue;
            d[y]=d[x]+1;
            f[y][0]=x;
            g[y][0]=z;
            for(int j=1;j<=t;j++)
            {
                f[y][j]=f[f[y][j-1]][j-1];

                g[y][j]=max(g[y][j-1],g[f[y][j-1]][j-1]);
            }
            q.push(y);
        }
    }
    return ;
}


void fuck(int &y,int i)
{
    max1=max(max1,g[y][i]);
    y=f[y][i];
}

int lca(int x,int y,int z)
{
    if(d[x]>d[y]) swap(x,y);
    max1=-inf;
    for(int i=t;i>=0;i--)
        if(d[f[y][i]]>=d[x]) fuck(y,i);

    if(x==y) return z-max1;

    for(int i=t;i>=0;i--)
        if(f[y][i]!=f[x][i]) fuck(x,i),fuck(y,i);

    fuck(x,0),fuck(y,0);
    return z-max1;

}


int main(void)
{

    int t;
    scanf("%d",&t);
    while(t--)
    {

        scanf("%d%d",&n,&m);
        init(n);

        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            a[i]=node(x,y,z);
        }
        sort(a+1,a+m+1,cmp);

        int cnt=0;
        int ans=0;
        for(int i=1;i<=m;i++)
        {
            int xx=fi(a[i].x);
            int yy=fi(a[i].y);
            if(xx==yy) continue;

            ha[i]=true;
            ff[xx]=yy;
            add(a[i].x,a[i].y,a[i].z);
            add(a[i].y,a[i].x,a[i].z);
            cnt++;ans+=a[i].z;
            if(cnt==n-1) break;
        }
        if(cnt!=n-1)
        {
            printf("Not Unique!\n");
            continue;
        }
        if(m==n-1)
        {
            printf("%d\n",ans);
            continue;
        }
        bfs();

        int res=inf;
        for(int i=1;i<=m;i++)
        {
            if(ha[i]) continue;
            res=min(res,lca(a[i].x,a[i].y,a[i].z));
        }

        if(res) printf("%d\n",ans);
        else printf("Not Unique!\n");

    }
    return 0;
}

其实我觉得倍增的复杂度已经足够找次小生成树了，下面两种由最小生成树变形而来的算法也了解一下：
数据真水，类似于dp，也类似于lca的找法，维护一个最大值：
Prim

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=1008;
const int inf=0x3f3f3f3f;
int n,m,w[maxn][maxn];
int d[maxn];
bool ha[maxn];
int maxx[maxn][maxn];
int pre[maxn];
bool mst[maxn][maxn];

int Prim(int s) {
    memset(d,0x3f,sizeof(d));
    memset(maxx,0,sizeof(maxx));
    memset(ha,0,sizeof(ha));
    memset(mst,0,sizeof(mst));
    for(int i=1;i<maxn;i++)
        pre[i]=s;
    d[s]=0;
    priority_queue<pair<int,int> > q;
    q.push(make_pair(0,s));

    int res = 0;
    while(!q.empty()) {
        int x=q.top().second;
        q.pop();

        if(ha[x]) continue;
        ha[x]=true;
        res+=d[x];

        mst[x][pre[x]]=mst[pre[x]][x]=true;
        for(int y=1;y<=n;y++) {
            if(ha[y])
                maxx[x][y]=maxx[y][x]=max(maxx[pre[x]][y],d[x]);
            if(!ha[y]&&d[y]>w[x][y]) {
                d[y]=w[x][y];
                pre[y]=x;
                q.push(make_pair(-d[y],y));
            }
        }
    }
    return res;
}


int main(void)
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(w,0x3f,sizeof(w));
        scanf("%d%d",&n,&m);
        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            w[x][y]=w[y][x]=z;
        }

        int ans=Prim(1);
        bool flag=false;
        for(int x=1;x<=n&&!flag;x++)
        {
            for(int y=1;y<=n;y++)
            {
                if(mst[x][y]||w[x][y]==inf) continue;

                if(w[x][y]==maxx[x][y])
                {
                    flag=true;
                    break;
                }
            }
        }

        if(flag) printf("Not Unique!\n");
        else printf("%d\n",ans);
    }
    return 0;
}

这个因为是按权值排序的，后更新的一定比先更新的大：
这题数据是真水。。。。
怎么写几乎都能过：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=108;
const int inf=0x3f3f3f3f;
int n,m;
struct node
{
    int x,y,z;
}a[maxn*maxn];
bool ha[maxn*maxn];
int maxx[maxn][maxn];
int f[maxn];
vector<int>mst[maxn];

bool cmp(const node &a,const node &b)
{
    return a.z<b.z;
}

int fi(int x)
{
    if(x!=f[x])
        f[x]=fi(f[x]);
    return f[x];
}

int ku(void)
{

    sort(a+1,a+m+1,cmp);
    memset(maxx,0,sizeof(maxx));
    memset(ha,0,sizeof(ha));
    for(int i=1;i<maxn;i++)
    {
        f[i]=i;
        mst[i].clear();
        mst[i].push_back(i);
    }

    int ans=0;
    int cnt=0;

    for(int i=1;i<=m;i++)
    {
        int xx=fi(a[i].x);
        int yy=fi(a[i].y);
        if(xx==yy) continue;

        ans+=a[i].z;
        cnt++;
        ha[i]=true;
        f[xx]=yy;


        for(int j=0;j<mst[xx].size();j++)
        {
            for(int k=0;k<mst[yy].size();k++)
            {
                maxx[mst[xx][j]][mst[yy][k]]=maxx[mst[yy][k]][mst[xx][j]]=a[i].z;
            }
        }
        for(int j=0;j<mst[xx].size();j++)
            mst[yy].push_back(mst[xx][j]);
    }

    if(cnt!=n-1) return -1;
    if(m==n-1) return ans;

    int res=inf;
    for(int i=1;i<=m;i++)
    {
        if(!ha[i])
            res=min(res,ans+a[i].z-maxx[a[i].x][a[i].y]);
    }
    return res>ans?ans:-1;
}


int main(void)
{
    int t;
    scanf("%d",&t);
    while(t--)
    {

        scanf("%d%d",&n,&m);
        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);

        }
        int ans=ku();
        if(ans==-1) printf("Not Unique!\n");
        else printf("%d\n",ans);
    }
    return 0;
}
_Shmily
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python最小生成树算法_最小生成树：Kruskal算法及python实现
weixin_42337065的博客
02-21 2750
本人数学专业本科，研究生读的计算机，方向是深度学习相关的，在平时上课和自己自学，看论文都是深度学习和机器学习相关的。打算毕业之后从事机器学习相关工作，但是不知道学完Dl，ML的相关算法之后，还需不需要学习传统的数据结构，比如二叉树，图，队列，栈什么的，还有必要学习算法导论里的算法吗？如果都学的话，那感觉时间不够，而且这些难度都挺大的。有没有前辈来指点一二呢？这是今天逛知乎时看到的一个提问“学习机器...
最小生成树：Prim算法
大力海棠的博客
09-17 2万+
讲构建最小生成树的算法前，先来回顾一下什么是生成树，什么是最小生成树？生成树是指：在一个连通图Graph中，包含Graph中所有n个顶点的极小连通子图，一定包含Graph中的n-1条边（如果小于n-1条边，生成树会不连通。如果大于n-1条边，就一定会产生回路，那么就不是树了，树中不能产生回路）。且生成树不唯一。举个例子： 这个无向连通图的生成树分别有 什么是最小生成树？ ...
最小生成树：
Dwyane0030的博客
10-29 2030
最小生成树：
最小生成树详解(模板 + 例题)
热门推荐
潘小蓝的博客
10-15 12万+
作为一个伪ACMer,先来首广为人知的打油诗: 模拟只会猜题意，贪心只能过样例，数学上来先打表，规律一般是DP，组合数学碰运气，计算几何瞎暴力，图论一顿套模板，数论只会GCD,递归递推伤不起，搜索茫然TLE，分治做得像枚举，暴力枚举数第一，数据结构干瞪眼，怒刷水题找信心。 文章目录1、什么是树2、最小生成树3、最小生成树的应用4、实现最小生成树的两种算法4.1 prim (普里姆算法)4.2 kruskal (克鲁斯卡尔算法)5、总结 1、什么是树 如果一个无向连通图不包含回路(连通图中不存在环),.
最小生成树&次小生成树算法精讲
吾谁知
10-31 2689
最小生成树 定义 最小生成树，是在一个n点边的强连通无向图中，边权值之和最小的n点n-1条边的强连通量（树），一般情况下可以与并查集同解，常见的使用prim和kruskal。 性质 MST性质：设G=(V，E）是一个连通网络，U是顶点集V的一个非空真子集。若(u，v）是G中一条“一个端点在U中（例如：u∈U），另一个端点不在U中的边（例如：v∈V-U），且（u，v）具有最小权值，则一定存在...
最小生成树
Tom的博客
05-08 6029
简单介绍两大算法——Prim算法 和 Kruskal 算法.
判断最小生成树的唯一性
Mr_dimple的博客
04-06 5313
先来看一个例题：Forsaken喜欢独一无二的树 题意： 现在给定一个 nnn 个点，mmm 条边的图，每条边 eie_{i}ei​ 都有一个权值 wiw_{i}wi​ 。 刚开始最小生成树可能不唯一，现在可以删除一些边，使得剩下的边的最小生成树大小不变并且唯一。 求删除的边的权值和最小是多少? 分析： 什么样的边会影响到最小生成树的唯一性呢？ kruskal 求最小生成树 是将所有边权从小到大排序，然后判断当前边的两个端点所在连通块是否连通。如果没有连通，那么这条边就需要拿。 而此时如果有另外一条边，虽然
最小生成树问题：算法分析 & Java 实现
阿飞的博客
10-23 7104
一、简介 1. 什么是最小生成树 将一个有权图中的所以顶点都连接起来，并保证连接的边的总权重最小，即最小生成树（mini spanning tree）问题。 例如，电子电路设计中，将所有组件的针脚连接在一起，且希望所使用的连线长度最短。 2. 图示 如上图（这里借用的是《算法导论》一书中的图）所示，每条边上的数字表示权重。我们使用阴影边连接了所有的顶点，并保证了其总权重是最小的。 注意最小生成树...
最短路径和最小生成树
最新发布
Netfilter
06-18 1万+
自然长大的树(非刻意修剪的盆景)，动物体内的血管，甚至从集市自然形成的城市道路，帝国扩张，都是最小生成树，个中原因就是自然选择，如果它们不 “最小”，就会有更小的树取而代之。这些都是自然而然的过程，就像我在描述最短路径算法时想表达的一样，最小生成树比最短路径表达的更多，它是个熵减过程，信息交换，环路修剪本身就需要额外的成本，所以它更多描述的是一些生物学或社会学的过程，而不是无机物世界的自然现象。对于最小生成树，它和最短路径同样容易理解，比如自然界中能看到的树，几乎都是最小生成树。至于 STP，会配就行。
MATLAB 最小生成树
小嗷犬的博客
02-06 3556
本文介绍了 MATLAB 中如何求解最小生成树。
次小生成树
08-23
根据题目给出的例子，我们可以通过以下步骤找到次小生成树： 1. **输入**：首先读取输入数据，包括城市的数量 \( N \) 和可建铁路的数量 \( M \)，以及每条铁路的成本。 2. **构建最小生成树**：使用 Kruskal 算法...
详解次小生成树以及相关的C++求解方法
09-03
次小生成树是图论中的一个重要概念，它在图G中是指权值次于最小生成树的另一种生成树。在给定的连通无向图G=(V,E,w)中，最小生成树T是一个权值之和最小的树，而次小生成树T1则是权值之和仅次于最小生成树的树，且...
最小生成树问题：给定一个无向图，求最小生成树
05-20
最小生成树（Minimum Spanning Tree, MST）是图论中的一个重要概念，主要应用于网络设计、数据传输优化等领域。在无权图或有权图（边带有权重）中，寻找一棵包括所有顶点的树，使得这棵树的所有边的权重之和最小，...
C语言实现最小生成树构造算法
01-21
最小生成树 最小生成树（minimum spanning tree）是由n个顶点，n-1条边，将一个连通图连接起来，且使权值最小的结构。 最小生成树可以用Prim（普里姆）算法或kruskal（克鲁斯卡尔）算法求出。 我们将以下面的带权...
不可视境界线（inv） KD-Tree 模板
_Griefs
08-24 1351
这个题可以转化一下。 dp [ i ] = min ( dp [ i ] , sqrt ( dp [ j ] * dp [ j ] + dis ( i , j ) ) ) i点 ( 0 , ai1 , ai2 ) j点 ( dpj , aj1 , aj2) 就是求 i 点之前距离 i 最近的点。 其中： k=1时是二维坐标。 k=2时是三维坐标。 #include<iostream&gt...
最近公共祖先（LCA）
_Griefs
08-24 1221
一、基本概念：   给定一棵有根树，若节点z既是节点x的祖先，也是节点y的祖先，则称z是x，y的公共祖先。在x，y的所有公共祖先中，深度最大的一个称为x，y的最近公共祖先，记为LCA（x，y）。   LCA（x，y）是x到根的路径与y到根的路径的交汇点。它也是x与y之间的路径上深度最小的节点。求最近公共祖先的方法通常有五种。   在此介绍三种，另外两种还没学。 二、向上标记法：   从x向上走到根...
哈夫曼树，哈夫曼编码：
_Griefs
08-24 932
一、哈夫曼树： ①、 P1090 合并果子： 题目描述 在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过 n-1次合并之后， 就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家，所...
树状数组
_Griefs
08-24 516
一、树状数组的基本应用：   其基本用途是维护前缀和。对于给定的序列a，我们建立一个数组c，c（x）保存序列a的区间[x-lowbit（x）+1，x]中所有数的前缀和。      事实上，数组c可以看作一个树形结构。叶子节点为a[1–N]。   （1）每个内部节点c（x）保存以它为根的子树中所有叶节点的和。   （2）每个内部节点c（x）的子节点个数等于lowbit（x）的位数。   （3）除树根...
生成树计数
_Griefs
08-24 452
一、生成树计数： 例①：Highways SPOJ - HIGH In some countries building highways takes a lot of time… Maybe that’s because there are many possiblities to construct a network of highways and engineers can’t make u...
图的遍历与最小生成树：普里姆算法解析
最小生成树是一棵树，它包含了原图的所有顶点，并且所有边的权重之和尽可能小。这个过程可以从任意一个顶点开始，逐步添加边，直到包含所有顶点为止。 普里姆算法的基本步骤如下： 1. 选择一个起始顶点，将其加入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值