最小生成树 （hdu）1102 1162 1233 1301 1863 7875 7873

最新推荐文章于 2019-07-29 17:10:04 发布
最新推荐文章于 2019-07-29 17:10:04 发布
阅读量434 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljlhnick/article/details/52125679
版权

大家都知道最小生成树有两种算法：prim(普利姆)———从点考虑，kruskal(克鲁斯卡)————从边考虑

初学最小生成树时，看的这篇博文，感觉棒棒哒点击打开链接

点击打开链接

 

hdu 1233 最小生成树
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#define N 100100
using namespace std;
struct node{
    int a,b,c;
}mapp[N];
int fa[N];
int com(node t1,node t2){
    return t1.c<t2.c;///按权重小的将边排序
}
///并查集查找每个点的父亲节点来判断两点是否都已经加入新图中以及判断图是否连通
int findfa(int x){
    if(x!=fa[x])
        fa[x]=findfa(fa[x]);
    return fa[x];
}
int main(){
    int n,m,i,fx,fy,res;
    while(scanf("%d",&n)!=EOF&&n){
       m=n*(n-1)/2;
       res=0;
       for(i=1;i<=n;i++) fa[i]=i;
       for(i=1;i<=m;i++)
            scanf("%d %d %d",&mapp[i].a,&mapp[i].b,&mapp[i].c);
       sort(mapp+1,mapp+m+1,com);
       for(i=1;i<=m;i++){
            fx=findfa(mapp[i].a);   fy=findfa(mapp[i].b);
             if(fx!=fy){///若附近节点不同，就把它两之间的边加入新图中
                fa[fx]=fy;///并且使其中任意一方的父亲节点更新成另一方的父亲节点
                res+=mapp[i].c;
                --n;
            }
       }
       printf("%d\n",res);
    }
    return 0;
}

hdu 1162

 

点击打开链接

 

<span style="font-size:14px;">普莱姆算法  prim</span>
#include<stdio.h>
#include <string.h>
#include<stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;
int mark[11000],n;
double mapp[11000][11000],dist[11000],left[11000],right[11000];
///函数也要变类型
double prim(){
    int i,j,k;
    double sum=0.0,min;
    for(i=0;i<n;i++)
    dist[i]=mapp[0][i];
    dist[i]=0,mark[0]=1;
    for(i=1;i<n;i++){
        min=1542487693.00,k=-1;//这里的min也要变成double类型
        for(j=0;j<n;j++)
        if(dist[j]<min&&mark[j]==0){
            min=dist[j];
            k=j;
        }
        mark[k]=1;
        if(k==-1)    break;
        else{
        sum+=dist[k];
        for(j=0;j<n;j++)
        if(mark[j]==0&&mapp[k][j]<dist[j])
        dist[j]=mapp[k][j];
        }
    }
    return sum;
}
int main()
{
    int i,j,k;
    double ans=0.0;
    while(scanf("%d",&n)!=EOF){
        memset(mark,0,sizeof(mark));
        for(i=0;i<n;i++)
        scanf("%lf %lf",&left[i],&right[i]);//注意是double类型的
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                if(i!=j){
                    mapp[i][j]=sqrt((left[i]-left[j])*(left[i]-left[j])+(right[i]-right[j])*(right[i]-right[j]));
                    mapp[j][i]=mapp[i][j];
                }
        ans=prim();
        printf("%.2f\n",ans);  
    }
    return 0;
}           
克鲁斯卡算法 kruskal
#include<cstdio> 
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int m,per[500];
struct node {
    int x,y;
    double dis;//注意类型
}s[10000000];
double cmp(node x,node y)
{
    return x.dis<y.dis;
}
int find(int x)
{
    /*非递归法查找父亲结点
    int i=x,t=x,j;
    while(t!=per[t])
    t=per[t];
    while(i!=t)
    {
        j=per[i];
        per[i]=t;
        i=j;
    }
    return t;
    */
    if(x!=per[x])
    per[x]=find(per[x]);
    return per[x];
}
int main()
{
    int i,j,t,fx,fy;;
    double a[500],b[500],sum;
    while(scanf("%d",&m)!=EOF){
    for(i=0;i<m;i++)    per[i]=i;
    for(i=0;i<m;i++)
        scanf("%lf %lf",&a[i],&b[i]); 
    t=0;sum=0.0;
    for(i=0;i<m;i++)
    {
        for(j=0;j<i;j++)
        {
            s[t].x=i;
            s[t].y=j;
            double q=(sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])*1.0));
            ///if(q<=1000&&q>=10)
            s[t++].dis=q;
        }
    }
    sort(s,s+t,cmp);
    for(i=0;i<t;i++)
    {
        fx=find(s[i].x),fy=find(s[i].y);
        if(fx!=fy){
        per[fx]=fy;
        sum+=s[i].dis;
        }
    }
    printf("%.2f\n",sum);
    }
    return 0;
}

hdu 1102

 

点击打开链接

 

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#define Y 0x3f3f3f3f
#define N 11100000
using namespace std;
int n,mapp[350][350],dist[350],mark[350];
int prim(){
    memset(mark,0,sizeof(mark));
    int i,j,minn,k,sum=0;
    for(i=1;i<=n;i++)
    dist[i]=mapp[1][i];
    dist[1]=0,mark[1]=1;
    for(i=1;i<n;i++){
        minn=Y,k=-1;
        for(j=1;j<=n;j++)
        if(mark[j]==0&&dist[j]<minn){
            minn=dist[j];
            k=j;
        }
        mark[k]=1;
        if(k==-1)    break;///若图不连通
        else{
            sum+=dist[k];
            for(j=1;j<=n;j++)
            if(mark[j]==0&&mapp[k][j]<dist[j])
            dist[j]=mapp[k][j];
        }
    }
    return sum;
}
int main() {
    int m,a,b,y,i,j;
    while(scanf("%d",&n)!=EOF){
    for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
    scanf("%d",&mapp[i][j]);
    scanf("%d",&m);///强已经建好的路权重归零
    for(i=1;i<=m;i++){
    scanf("%d %d",&a,&b);
    mapp[a][b]=mapp[b][a]=0;
    }
    y=prim();
    printf("%d\n",y);
    }
    return

hdu 1874

 

点击打开链接

 

普莱姆算法
#include <iostream>
#include <queue>
#include <string.h>
#define Y 111100
#define N 1100
using namespace std;
int mapp[N][N],mark[N],dist[N],n,m,s,t;
void dijsta(int v0){
    int i,j;
    for(i=0;i<n;i++)
        dist[i]=mapp[v0][i];
    mark[v0]=1;  dist[v0]=0;
    for(i=1;i<n;i++){
        int minn=Y,k=-1;
        for(j=0;j<n;j++)
            if(minn>dist[j]&&mark[j]==0)
            {   minn=dist[j];
                k=j;
            }
        mark[k]=1;
        if(k!=-1){
            for(j=0;j<n;j++)
                if(mapp[k][j]<Y&&mark[j]==0){
                    if(dist[k]+mapp[k][j]<dist[j])
                        dist[j]=dist[k]+mapp[k][j];
                }
        }
    }
}
int main()
{
    int a,b,c,i,j,y=0;
    while(cin>>n>>m){
        memset(mark,0,sizeof(mark));
        memset(dist,0,sizeof(dist));
        for(i=0;i<n;i++){
            for(j=0;j<n;j++){
                mapp[i][j]=Y;
            }
        }
        for(i=0;i<m;i++){
            cin>>a>>b>>c;
            if(mapp[a][b]>c)
            mapp[a][b]=mapp[b][a]=c;
        }
        cin>>s>>t;
        dijsta(s);
        y=dist[t];
        if(y==Y)
            cout<<"-1"<<endl;
        else
            cout<<y<<endl;
    }

    return 0;
}

 

 

 

 

 

hdu 1875

点击打开链接

 

普莱姆算法 prim
#include<stdio.h>
#include <string.h>
#include<stdlib.h>
#include <math.h>
#include <algorithm>
#define Y 111110000
using namespace std;
int mark[11000],n,left[11000],right[11000];
double mapp[11000][11000],dist[11000];
///注意类型
double prim(){
    int i,j,k;
    double sum=0.0,min;
    for(i=0;i<n;i++)
    dist[i]=mapp[0][i];
    dist[0]=0,mark[0]=1;
    for(i=1;i<n;i++){
        min=1542487693.00,k=-1;
        for(j=0;j<n;j++)
        if(dist[j]<min&&mark[j]==0){
            min=dist[j];
            k=j;
        }
        mark[k]=1;
        if(k==-1) break;    ///若没找到满足条件的下标
        else{
        sum+=dist[k];
        for(j=0;j<n;j++)
        if(mark[j]==0&&mapp[k][j]<dist[j])
        dist[j]=mapp[k][j];
        }
    }
    return sum;
}
int main()
{
    int T,i,j,k;
    double ans=0.0,d;
    scanf("%d",&T);
    while(T--){
    scanf("%d",&n);
        memset(mark,0,sizeof(mark));
        for(i=0;i<n;i++)
        scanf("%d %d",&left[i],&right[i]);
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                if(i!=j){
                    d=sqrt((left[i]-left[j])*(left[i]-left[j])+(right[i]-right[j])*(right[i]-right[j]));
                    if(d>=10&&d<=1000)
                    mapp[j][i]=mapp[i][j]=d;
                    else
                    mapp[j][i]=mapp[i][j]=Y;
                }
        ans=prim();
        if(ans<Y)
        printf("%.1lf\n",ans*100.0);  
        else
        printf("oh!\n");
    }
    return 0;
}             
克鲁斯卡算法 kruskal
#include<cstdio> 
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int m,per[500],cot;
struct node {
    int x,y;
    double dis;
}s[10000000];
double cmp(node x,node y)
{
    return x.dis<y.dis;
}
int find(int x)
{
    /*
    int i=x,t=x,j;
    while(t!=per[t])
    t=per[t];
    while(i!=t)
    {
        j=per[i];
        per[i]=t;
        i=j;
    }
    return t;
    */
    if(x!=per[x])
    per[x]=find(per[x]);
    return per[x];
}
int main()
{
    int N,n,a[300],b[300],i,j;
    scanf("%d",&N);
    while(N--)
    {
        cot=0;
        scanf("%d",&m);
        for(i=0;i<m;i++)
        per[i]=i;
        for(i=0;i<m;i++)
            scanf("%d%d",&a[i],&b[i]);
            int t=0;
        for(i=0;i<m;i++)
        {
            for(j=0;j<i;j++)
            {
                s[t].x=i;
                s[t].y=j;
                double q=(sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])*1.0));
                if(q<=1000&&q>=10)
                s[t++].dis=q;
            }
        }
        sort(s,s+t,cmp);
        double sum=0;
        int fx,fy;
        for(i=0;i<t;i++)
        {
            fx=find(s[i].x),fy=find(s[i].y);
            if(fx!=fy){
            cot++;
            per[fx]=fy;
            sum+=s[i].dis;
            }
        }
        if(cot!=m-1)
        printf("oh!\n");
        else
        printf("%.1lf\n",sum*100);
    }
    return 0;
}

hdu 1879

 

点击打开链接

 

普莱姆算法
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <string.h>
#define N 200
#define Y 900
using namespace std;
int n,m,dist[N],mapp[N][N],mark[N];
int Prime()
{
    int sum=0,i,j;
    for(i=1;i<=n;i++)
        dist[i]=mapp[1][i];
    mark[1]=1;dist[1]=0;
    for(i=1;i<n;i++){
        int minn=Y,k=-1;
        for(j=1;j<=n;j++)
            if(minn>dist[j]&&mark[j]==0)
            {   minn=dist[j];
                k=j;
            }
        mark[k]=1;
        if(k!=-1){
            sum+=dist[k];
            for(j=1;j<=n;j++)
                if(dist[j]>mapp[k][j]&&mark[j]==0)
                    dist[j]=mapp[k][j];
        }
    }
    return sum;
}

int main()
{
    int i,j;
    int a,b,c,d;
    while(scanf("%d",&n)!=EOF&&n){
    m=n*(n-1)/2;memset(
    mark,0,sizeof(mark));
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
        mapp[i][j]=Y;
    for(i=1;i<=m;i++){
        scanf("%d %d %d %d",&a,&b,&c,&d);
        if(d==0)
            mapp[a][b]=mapp[b][a]=c;
        else
            mapp[a][b]=mapp[b][a]=0;
    }
    printf("%d\n",Prime());
    }
    return 0;
}
克鲁斯卡算法
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#define N 200
using namespace std;
struct node{
    int a,b,c;
}mapp[N*N];
int fa[N];
int com(struct node t1,struct node t2){
    return t1.c<t2.c;
}
int findfa(int x){
    if(x!=fa[x])
        fa[x]=findfa(fa[x]);
    return fa[x];
}
int main()
{
    int n,i,fx,fy,res,t;
    while(scanf("%d",&n)&&n){
    res=0;
    for(i=1;i<=n;i++)   fa[i]=i;
    for(i=1;i<=n*(n-1)/2;i++){
    scanf("%d %d %d %d",&mapp[i].a,&mapp[i].b,&mapp[i].c,&t);
    if(t==1)
    mapp[i].c=0;
    }
    sort(mapp+1,mapp+n*(n-1)/2+1,com);
    for(i=1;i<=n*(n-1)/2;i++){
        fx=findfa(mapp[i].a);   fy=findfa(mapp[i].b);
        if(fx!=fy){
            fa[fx]=fy;
            res+=mapp[i].c;
        }
    }
    printf("%d\n",res);
    }
    return 0;
}

hdu 1301   前面感觉都是模板，这次来点不同的最小生成树，不同就在于n表示点的个数，而每个点的标号不在是数字而是大写字母，每行首个大写字母的后面的数字表示有几个点与行首大写字母相连，后面的数字表示两点之间的权重。求是图连通的最小生成树

 

点击打开链接

克鲁斯卡算法
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#define N 100100
using namespace std;
struct node{
    int a,b,c;
}mapp[N];
int fa[N];
int com(node t1,node t2){
    return t1.c<t2.c;
}
int findfa(int x){
    if(x!=fa[x])
        fa[x]=findfa(fa[x]);
    return fa[x];
}
int main(){
    int n,m,i,j,p,q,fx,fy,res,l;
    char c1,c2;
    while(scanf("%d%*c",&n)!=EOF&&n){
       m=n-1;
       res=0;
       l=0;
       for(i=1;i<=n;i++) fa[i]=i;
       for(i=1;i<=m;i++){
            scanf("%c %d%*c",&c1,&p);
            for(j=1;j<=p;j++){
                scanf("%c %d%*c",&c2,&q);///%*c相当于getchar()
                l++;
                mapp[l].a=c1-'A'+1; mapp[l].b=c2-'A'+1; mapp[l].c=q;///把每个字母编号转换成数字编号
            }

       }
       sort(mapp+1,mapp+l+1,com);
       for(i=1;i<=l;i++){
            fx=findfa(mapp[i].a);   fy=findfa(mapp[i].b);
            if(fx!=fy){
                fa[fx]=fy;
                res+=mapp[i].c;
                --n;
            }
       }
       printf("%d\n",res);
    }
    return 0;
}

hdu 1863

 

点击打开链接

普莱姆算法 
<pre name="code" class="html">#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#define N 200
#define Y 33333110
using namespace std;
int mapp[N][N],mark[N],dist[N],n,m,sum;
int prim(int v0){
    memset(mark,0,sizeof(mark));
    int i,j,minn,k,sum=0;
    for(i=1;i<=n;i++)
        dist[i]=mapp[v0][i];
    mark[v0]=1;  dist[v0]=0;
    for(i=1;i<n;i++){
        minn=Y;k=-1;
        for(j=1;j<=n;j++)
            if(mark[j]==0&&minn>dist[j]){
                minn=dist[j];
                k=j;
            }
        mark[k]=1;
        if(k==-1){
            return Y;
        }
        if(k!=-1){
            sum+=dist[k];
            for(j=1;j<=n;j++)
                if(mark[j]==0&&mapp[k][j]<dist[j])
                dist[j]=mapp[k][j];
            }
        }
    return sum;
}
int main()
{
    int i,j,a,b,c,y;
    while(cin>>m&&m){
        cin>>n;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
        mapp[i][j]=Y;
    for(i=1;i<=m;i++){
        cin>>a>>b>>c;
        if(mapp[a][b]>c)
        mapp[a][b]=mapp[b][a]=c;
    }
    y=prim(1);
    if(y==Y)
        cout<<"?"<<endl;
    else
        cout<<y<<endl;
    }
    return 0;
}

克鲁斯卡算法

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#define N 200
#define Y 33333110
using namespace std;
struct node{
    int a,b,c;
}mapp[N*6];
int fa[N*6];
int com(node t1,node t2){
    return t1.c<t2.c;
}
int findfa(int x){
    if(x!=fa[x])
        fa[x]=findfa(fa[x]);
    return fa[x];
}
int main()
{
    int n,m,i,fx,fy,res;
    while(cin>>m&&m){
        cin>>n;
    res=0;
    for(i=1;i<=n;i++)   fa[i]=i;
    for(i=1;i<=m;i++)
        cin>>mapp[i].a>>mapp[i].b>>mapp[i].c;
    sort(mapp+1,mapp+m+1,com);
    for(i=1;i<=m;i++){
        fx=findfa(mapp[i].a);   fy=findfa(mapp[i].b);
        if(fx!=fy){
            fa[fx]=fy;
            res+=mapp[i].c;
            --n;
        }
    }
    if(n>1)
        cout<<"?"<<endl;
    else
       cout<<res<<endl;
    }
    return 0;
}

我记得还有一道题，可是翻不到了，以后再来不吧
 

 

 

 

 

 

 

 

 

 

 

ljlhnick
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu1102&hdu4081最小生成树，次小生成树
cww97的博客
05-19 687
hdu1102 MST模板题 复习下kruskal，补一下之前偷懒没学的prim赤裸裸的kruskal#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std; const int N=107; int n,m,g[N][N]; struct Edge{ in
最小生成树(Kruskal)HDU 1863-畅通工程
[SZU_Crayon]
08-26 415
最小生成树(Kruskal)HDU 1863-畅通工程 题目链接： 畅通工程 题目基础： 最小生成树-Kruskal(克鲁斯卡尔)算法 思路： 题目大意： 中文题目略 题解： Kruskal水题，有个概念，如果M个村庄能够连通，并且是在并查集下连通，需满足道路数Road_Num=M-1 所以在题目中，如果合并的道路小于M-1，是不能将M个村庄连通的 ...
HDU1102 Constructing Roads 最小生成树prim||kruskal
xyry
08-28 308
题目链接：HDU1102 很裸的题目，下面给出prim算法和kruskal算法解题代码，直接套模板即可。 AC代码： prim()算法 /* 2017年8月28日15:57:26 HDU1102 最小生成树 prim算法 AC */ #include //#include #include #include #include #include #include #incl
HDU1863——Prim最小生成树
qq_41508508的博客
07-15 192
这道题直接裸Prim。复习一下Prim算法。// // main.cpp // hdu1863 // // Created by jinyu on 2018/7/15. // Copyright © 2018年 jinyu. All rights reserved. // #include &lt;iostream&gt; using namespace std; const int ...
hdu1863通信工程（最小生成树）
weixin_43736492的博客
06-01 230
畅通工程 Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 43973 Accepted Submission(s): 19664 Problem Description 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交...
hdu1162 Eddy's picture 最小生成树 prim
苏苏爱自由
04-18 1477
Eddy's picture Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 10218    Accepted Submission(s): 5162 Problem Description Eddy begin
HDU 1863-畅通工程-最小生成树
Nothing_but_Fight的博客
07-29 149
题目描述： 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。 输入描述： 测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N行对应村庄间道路的成...
hdu1102 Constructing Roads （最小生成树，kruskal）
把复杂的事情简单描述
11-20 516
Constructing Roads Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 18127    Accepted Submission(s): 6907 Problem Description Th
HDU - 1863［畅通工程］ 最小生成树Kruskal
Venishel的博客
07-14 440
hdu1863 畅通工程
最小生成树
04-10
HDUACM201509版_07并查集（最小生成树）.ppt文件很可能包含了关于这个问题的详细讲解，包括并查集的建立、维护以及如何与Kruskal算法结合来求解最小生成树的问题。 并查集是一种用于处理连接关系的数据结构，它可以...
（HDUACM2010版_06）并查集（最小生成树）
10-12
（HDUACM2010版_06）并查集（最小生成树（HDUACM2010版_06）并查集（最小生成树（HDUACM2010版_06）并查集（最小生成树（HDUACM2010版_06）并查集（最小生成树
（HDUACM201403版_06）并查集（最小生成树）
08-23
杭电ACM课件2014版之 （HDUACM201403版_06）并查集（最小生成树）
hdu.rar_hdu
最新发布
09-23
3. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表、最小生成树、拓扑排序等）。 4. **字符串处理**：KMP算法、Manacher's Algorithm、Rabin-Karp算法等。 5. **...
hdu.zip_ACM_hdu
09-20
这些算法在解决实际问题时起着关键作用，比如寻找最短路径、最大子序列和、最小生成树等。 针对杭电HDU的题目，很可能需要运用到上述的一种或多种数据结构和算法。例如，一道题目可能要求实现一个高效的查找算法，...
判断图的连通性
热门推荐
ljlhnick的博客
08-05 1万+
关于判断一个图的连通性有几种方法，下面为大家介绍几种简单的方法，好记又方便，难得我会提下（毕竟自己很菜，不会），大家想了解更多的可以自己百度 简单：1，可以用广搜遍历图（用邻接矩阵存的），若图能连通，那么比能访问完所有图中节点，核心代码如下： <span style="font-size:14px;color:#FF0000;"><strong>//申明邻接矩阵...
最短路习题集（hdu）
ljlhnick的博客
08-05 1319
下面把在杭电刷题的最短路的代码贴上 hdu 2544 点击打开链接 dijkstra算法 #include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> #define N 200 #define Y 33333110 using names...
Warshall传递闭包算法
ljlhnick的博客
08-05 1212
补充之前关于判断图的连通性的一个算法，吃完晚饭鸡血又回来了 一个有n个顶点的有向图的传递闭包为：有向图中的初始路径可达情况可以参见其邻接矩阵A，邻接矩阵中A[i,j]表示i到j是否直接可达，若直接可达，则A[i,j]记为1，否则记为0；两个有向图中i到j有路径表示从i点开始经过其他点（或者不经过其他点）能够到达j点，如果i到j有路径，则将T[i,j]设置为1，否则设置为0；有向图的传递闭包表示从...
统计工龄 模拟EXCEL排序 银行排队问题之单队列多窗口问题 银行业务队列简单模拟 堆栈操作合法性 两个有序序列的中位数
ljlhnick的博客
08-07 985
一波pta上的数据结构题 两个有序序列的中位数 点击打开链接 /*** 5 1 3 5 7 9 2 3 4 5 6 ***/ #include <iostream> #include <algorithm> #include <string.h> #define N 200005 using namespace std; int a[N]; int...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值