最小生成树算法

2017-11-20

（1）prim算法（平均时间复杂度为O（n^2））
有两个集合U与V，每次从V集合里选取从U集合里与V集合里距离最小的加入到集合U中直至集合U为全集。

#include<iostream>
#include<cstring>
#define MAX 65535
using namespace std;

const int N = 100;
int n;
int x[N+1][N+1],y[N+1];
bool z[N+1];

void init(){
    int m;
    cin>>n>>m;
    for (int i=1;i<=n;i++){
        for (int j=1;j<=n;j++){
            x[i][j]=MAX;
        }
    }
    for (int i=1;i<=m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        x[a][b]=c;
        x[b][a]=c;
    }
    memset(z,0,sizeof(z));
    y[1]=1;z[1]=1;
}

int res(){
    int s1=1,min_point,result=0;
    while(s1<n){
        int min_path=MAX;
        for (int i=1;y[i]!=0;i++){
            for (int j=1;j<=n;j++){
                if (!z[j]&&x[y[i]][j]<min_path){
                    min_path=x[y[i]][j];
                    min_point=j;
                }
            }
        }
        s1++;
        result+=min_path;
        y[s1]=min_point;
        z[min_point]=1;
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

自己写的复杂度好像挺高的

我的想法是：首先用邻接矩阵X存边的权值信息，初始化全为最大值65536，当然，这是一个图，所以需要X[a][b]=X[b][a].我还用了两个数组y以及z。其中y是用来存放已经加入到该最小生成树的点，初始化我设置第一个点加入了进去，所以y[1]=1，每加入一个点进去s1的值就加一，直至s1为n；z数组是用来判断该点是否已经计算过了，初始化时z[i]=i，若z[i]为0，则表明该点已经算过了。每次我们循环的时候，从y数组中的第一个元素开始，从z数组中找到与该元素距离最小的点j加入到y数组中去，同时z[j]设为0，这样，我们直到所有的点都加入到y数组即可。
嗯额！其实z数组是没有必要的，我们只要用一个flag数组比较该点在哪一个集合里面就可以了。
但是我的复杂度接近O(n^3)，这可能很难以让人接受。。。
第一个循环表示当前已经加几个点到集合中去了，
第二个循环遍历所有加入到已经算过的点的集合的点，
第三个循环遍历与该算过的点相连接的点，求得最小的权值，
有必要解释一些我的代码，y数组是随着s1的值一点一点赋值的，下标并不代表点，所以说我的第二个关于i的循环在y[i]为零的时候就已经结束了。

#include<iostream>
#include<cstring>
#define MAX 65535
using namespace std;

const int N = 1000;
int n;
int x[N+1][N+1],y[N+1];
bool z[N+1];

void init(){
    int m;
    cin>>n>>m;
    for (int i=1;i<=n;i++){
        for (int j=1;j<=n;j++){
            x[i][j]=MAX;
        }
    }
    for (int i=1;i<=m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        c=min(c,x[a][b]);
        x[a][b]=c;
        x[b][a]=c;
    }
    memset(z,0,sizeof(z));
    z[1]=1;
    for (int i=1;i<=n;i++){
        y[i]=x[1][i];
    }
}

long long res(){
    long long result=0;
    for (int i=2;i<=n;i++){
        int min_path=MAX,min_pos=1;
        for (int j=1;j<=n;j++){
            if (j!=min_pos&&y[j]<min_path){
                min_path=y[j];
                min_pos=j;
            }
        }
        z[min_pos]=1;
        y[min_pos]=MAX;
        result+=min_path;
        for (int j=2;j<=n;j++){
            if (!z[j]&&x[min_pos][j]<y[j]){
                y[j]=x[min_pos][j];
            }
        }
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

说一下书上的方法吧！
我还是用了三个数组x，y，z，其中数组x还是邻接矩阵，存放了边的权值信息，但是数组y与之前稍有不同，z数组和之前还是一样的，如果z[i]为1的话表示我们已经将它加入到最小生成树中了。
还是说一下y数组的作用吧！
它存放的是当前已经加入到最小生成树的点到1~n的点的最小距离，刚开始的时候只有1这一个点在里面，所以y数组里面只要存储1~n到第一个点的距离即可，我们通过遍历y数组得到了最小值以及下一个要加入到最小生成树中的点，那么我们就要用这个点来更新y数组了，如果说当前点到1~n的距离小于1到1~n的距离的话，我们就更新，这样的话，我们的时间复杂度就降到了O（n^2），因为我们不用再遍历所有在最小生成树中的点了，我们只要遍历y数组即可。

#include<iostream>
#include<cstring>
#define MAX 65535
using namespace std;

const int N = 1000;
int n;
int x[N+1][N+1],y[N+1];
bool z[N+1];

void init(){
    int m;
    cin>>n>>m;
    for (int i=1;i<=n;i++){
        for (int j=1;j<=n;j++){
            x[i][j]=MAX;
        }
    }
    for (int i=1;i<=m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        c=min(c,x[a][b]);
        x[a][b]=c;
        x[b][a]=c;
    }
    memset(z,0,sizeof(z));
    z[1]=1;
    for (int i=1;i<=n;i++){
        y[i]=x[1][i];
    }
}

long long res(){
    long long result=0;
    for (int i=2;i<=n;i++){
        int min_path=MAX,min_pos=1;
        for (int j=1;j<=n;j++){
            if (!z[j]&&y[j]<min_path){
                min_path=y[j];
                min_pos=j;
            }
        }
        z[min_pos]=1;
        result+=min_path;
        for (int j=2;j<=n;j++){
            if (!z[j]&&x[min_pos][j]<y[j]){
                y[j]=x[min_pos][j];
            }
        }
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

这一个代码做了一个稍稍的更改，如果z[i]已经是1了，那么我们就不用考虑当前的值与i的距离了。

（2）运用kruskal算法加上并查集（平均时间复杂度为O（eloge））

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100000;

struct xd{
    int s,e,w;
}x[N+1];
int m,n;
int f[N+1];

int cmp(struct xd &a,struct xd &b){
    return a.w<b.w;
}

void init(){
    cin>>n>>m;
    for (int i=1;i<=m;i++){
        cin>>x[i].s>>x[i].e>>x[i].w;
    }
    sort(x+1,x+m+1,cmp);
    for (int i=1;i<=n;i++) f[i]=i;
}

int find(int x){
    while (f[x]!=x){
        x=f[x];
    }
    return x;
}

long long res(){
    long long result=0;
    for (int i=1;i<=m;i++){
        int a=find(x[i].s);
        int b=find(x[i].e);
        if (a!=b){
            f[a]=b;
            result+=x[i].w;
        }
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

首先我们需要在所有边的权值中找到最小的（我们对所有的边的权值进行排序），对于该边的两个点，如果它们两个在不同的子树中，则我们加入这一条边；反之，如果它们两个在相同的子树中，则不予以考虑。当然，我们在判断两个点是否在相同的子树中时用的并查集。

当然还是要论一下并查集是怎么一步一步优化的，
它的思想很简单，用f数组来标记它的父节点是谁，祖上节点的f[i]为i！
最简单的就是一步一步向上找，看两个人的祖上节点是否相同，
但是如果说树长的太不平衡了以至于是线性的了，那么我们每次查找都会很慢，那么我们会考虑将比较矮的放在高树的那边，
最好的一种方法就是让节点直接指向它的祖上即可。

第二种算法较第一种算法时间复杂度降低为eloge了，这里的e是边的数量...

这两个算法各有各的优点：prim算法适合与比较边密集的图，是从点的角度进行求解的，而kruskal算法适合边比较稀疏的图，是从边的角度进行求解的。

CODEVS 1231 最优布线问题
该题目的主要大意就是让我们求出最小生成树，所给的数据范围比较大，我们选取第二种算法进行求解，需要我们注意的是，数据中可能存在权值不一样的重边，但是保证没有自环且题目保证一定存在可行的连通方案。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100000;

struct xd{
    int s,e,w;
}x[N+1];
int m,n;
int f[N+1];

int cmp(const struct xd &a,const struct xd &b){
    return a.w<b.w;
}

void init(){
    cin>>n>>m;
    for (int i=1;i<=m;i++){
        cin>>x[i].s>>x[i].e>>x[i].w;
    }
    sort(x+1,x+m+1,cmp);
    for (int i=1;i<=n;i++) f[i]=i;
}

int find(int x){
    while (f[x]!=x){
        x=f[x];
    }
    return x;
}

long long res(){
    long long result=0;
    for (int i=1;i<=m;i++){
        int a=find(x[i].s);
        int b=find(x[i].e);
        if (a!=b){
            f[a]=b;
            result+=x[i].w;
        }
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

以上的代码并没有进行路径压缩，当树的左右子树深度相差太大时，我们find函数递归的次数是比较多的，因而我们这段代码在最后一个测试数据光荣超时了，但是我们可以通过路径压缩的方法降低递归的次数，如果我们能够让子节点直接指向根节点是最好的了，这样我们find函数只需要O（1）的复杂度就可以实现了。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100000;

struct xd{
    int s,e,w;
}x[N+1];
int m,n;
int f[N+1];

int cmp(const struct xd &a,const struct xd &b){
    return a.w<b.w;
}

void init(){
    cin>>n>>m;
    for (int i=1;i<=m;i++){
        cin>>x[i].s>>x[i].e>>x[i].w;
    }
    sort(x+1,x+m+1,cmp);
    for (int i=1;i<=n;i++) f[i]=i;
}

int find(int x){
    int p=x;
    while (f[x]!=x){
        x=f[x];
    }
    int t=x;
    while (f[p]!=p){
        f[p]=t;
        p=f[p];
    }
    return t;
}

long long res(){
    long long result=0;
    for (int i=1;i<=m;i++){
        int a=find(x[i].s);
        int b=find(x[i].e);
        if (a!=b){
            f[a]=b;
            result+=x[i].w;
        }
    }
    return result;
}

int main(){
    init();
    cout<<res()<<endl;
    return 0;
}

我们对之前的代码进行了一些简单的修改就可以了。我的想法是在find函数中，我们的第一个循环求得了大家的根节点，我们在第二个循环中，只需要修改我们在寻找根节点的途中经过的节点即可，这样我们可以让他的孩子节点直接指向跟节点即可…