DAY57_图论7_寻宝.md

寻宝

题目理解

给定n个节点，某些节点之间的距离已知，求连通所有节点的最小距离和。

思路

第一步想要尝试确定所有点在二维平面上的位置。
首先确定其中一个节点，该节点的边的关系最多，然后根据该节点的辐射半径给出其他节点的可能位置，其次找到边的关系次多的节点，再去辐射半径关系，在这个过程中，需要兼顾第一个节点与其他节点的关系。
第二步是实现最短连通。连通需要任意两个点之间有路就可以。实现最短就是从第一个节点出发，连通距离该节点最近的节点，第三个节点和前两个节点的连通路径取决于前两个节点和第三个节点哪个节点相距更近，依次连通。

prim算法思路

1.选最近节点；
2.加入生成树；
3.更新节点到生成树的距离。

实现

#include<iostream>
#include<vector>
#include<climits>
using namespace std;
int main(){
    int v,e;
    int x,y,k;
    cin>>v>>e;
    vector<vector<int>> grid(v+1,vector<int>(v+1,10001));
    while(e--){
        cin>>x>>y>>k;
        grid[x][y]=k;
        grid[y][x]=k;
    }
    vector<int> minDist(v+1,10001);
    //minDist[1]=0;
    vector<bool> isInTree(v+1,false);
    for(int i=1;i<v;i++){
        int cur=-1;
        int minVal=INT_MAX;
        for(int j=1;j<=v;j++){
            if(!isInTree[j]&&minDist[j]<minVal){
                minVal=minDist[j];
                cur=j;
            }
        }
        isInTree[cur]=true;
        for(int j=1;j<=v;j++){
            if(!isInTree[j]&&grid[cur][j]<minDist[j]){
                minDist[j]=grid[cur][j];
            }
        }
    }
    int result=0;
    for(int i=2;i<=v;i++){
    result+=minDist[i];
    }
    cout<<result<<endl;
}

kruskal 算法

算法思路

节点在二维平面上的位置完全是给定的，意味着不需要修建新的路，只需要在已经存在的这些边里面挑选可以包含到所有节点的边。使边的集合最小。
1.首先找到最小的边，并将其连接的节点加入集合；
2.其次找到次小边，看其连接的两个节点是否连通，若果不连通，就加入该两个节点；

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct Edge{
    int l,r,val;
};
int n=10001;
vector<int> father(n,-1);
void init(){
    for(int i=0;i<n;i++){
        father[i]=i;
    }
}
int find(int u){
    return u==father[u]? u:father[u]=find(father[u]);
}
void join(int u,int v){
    u=find(u);
    v=find(v);
    if(u==v){return;}
    father[v]=u;
}
int main(){
    int v,e;
    int v1,v2,val;
    vector<Edge> edges;
    int result_val=0;
    cin>>v>>e;
    while(e--){
        cin>>v1>>v2>>val;
        edges.push_back({v1,v2,val});
    }
    sort(edges.begin(),edges.end(),[](const Edge&a,const Edge&b){return a.val<b.val;});
    init();
    for(Edge edge:edges){
        int x =find(edge.l);
        int y =find(edge.r);
            if(x!=y){
        result_val+=edge.val;
        join(x,y);
    }
    }
    cout<<result_val<<endl;
    return 0;
}

prim和kruskal的比较

在给定输入中，边的个数存在一个范围,节点数为n,边数为[n-1,C(n,2)]
C(n,2)= n*(n-1)/2;
边数越多，kruskal算法的时间复杂度越高。