利用Kruskal算法求最小生成树解决聪明的猴子问题 -- 数据结构

#include<iostream>
#include<cmath> 
#include<cstring>
#include <stdlib.h>
using namespace std;

#define max 1000

typedef struct point{
    int x, y;//坐标(x,y) 
    bool status;
}point;

typedef struct edge{
    point p1, p2;//边的两个端点 
    double weight;//边的权值 
}edge;

int cmp( const void *a ,const void *b);
double kruskal(edge *e, int tree_num, point *p);
int get_root(int *v, int x);
int search(point *p, point p1, int tree_num);
int main(){
    //输入猴子数量 
    int monkey_num;
    cin>>monkey_num;
    
    //输入猴子能到达的最远距离 
    int step[monkey_num];
    memset(step, 0, sizeof(step));
    for(int i=0; i<monkey_num; i++){
        cin>>step[i];
    }
    
    //输入树的数量 
    int tree_num;
    cin>>tree_num;
    
    //输入树的坐标（点记录） 
    point p[max];
    memset(p, 0, sizeof(p));
    for(int i=0; i<tree_num; i++){
        cin>>p[i].x>>p[i].y;
        p[i].status = 1;//status为1表示可操作的树 
    }
    
    //边记录 
    edge e[max];
    int t = 0;
    int vi[max] = {0};
    for(int i=0; p[i].status != 0; i++){
        for(int j=0; p[j].status != 0 ; j++){
            if(i != j && vi[j] == 0){//增加边的权值，两个端点 
                e[t].weight = sqrt((p[i].x-p[j].x)*(p[i].x-p[j].x) + (p[i].y-p[j].y)*(p[i].y-p[j].y));
                e[t].p1 = p[i];
                e[t++].p2 = p[j];
            }
        }
        vi[i] = 1;//标记p[i]点连接的所有边已经被读取 
    }    
    
    //按权值快速排序 
    qsort(e, tree_num*(tree_num-1)/2, sizeof(edge), cmp);
    
    double longest = kruskal(e, tree_num, p);
    
    int ans = 0;
    for(int i=0; i<monkey_num; i++){
        if(step[i] >= longest)ans++;
    }
    cout<<ans;
    
    return 0;    
}    

int cmp(const void *a, const void *b)
{
    return (*(edge *)a).weight > (*(edge *)b).weight ? 1 : -1;
}

double kruskal(edge *e, int tree_num, point *p)
{
    //并查集 
    int v[tree_num];
    for(int i=0; i<tree_num; i++){
        v[i] = i;
    } 
    
    double longest;

    int i1, i2;
    for(int i=0; i<tree_num*(tree_num-1)/2; i++){
        if(search(p, e[i].p1, tree_num) == -1 || search(p, e[i].p2, tree_num) == -1){
            exit(-1);//ERROR:没有找到e[i].p1在p[]中的坐标
        }
        //serach()查找 e[i].p1在p[]中的坐标 
        i1 = v[search(p, e[i].p1, tree_num)];
        i2 = v[search(p, e[i].p2, tree_num)];
      
        
        if(i1 == i2 == tree_num-1)break;//已经构建成最小生成树 
        if(i1 == i2)continue;//边的两个端点已经在同一个集合中 
        
        //将i1，i2中较大的作为标记 
        int i3 = i1>i2 ? i1:i2;
        for(int j=0; j<tree_num; j++){
            if(v[j] == i1 || v[j] == i2){
                v[j] = i3;
            }
        }
        longest = e[i].weight;
    }
    return longest;
}

int search(point *p, point p1, int tree_num)
{
    for(int i=0; i<tree_num; i++){
        if(p1.x == p[i].x && p1.y == p[i].y){
            return i;
        }
    }
    return -1;
}