最小生成树（Networking ）（非矩阵输入）

You are assigned to design network connections between certain points in a wide area. You are given a set of points in the area, and a set of possible routes for the cables that may connect pairs of points. For each possible route between two points, you are given the length of the cable that is needed to connect the points over that route. Note that there may exist many possible routes between two given points. It is assumed that the given possible routes connect (directly or indirectly) each two points in the area.
Your task is to design the network for the area, so that there is a connection (direct or indirect) between every two points (i.e., all the points are interconnected, but not necessarily by a direct cable), and that the total length of the used cable is minimal.      

Input

The input file consists of a number of data sets. Each data set defines one required network. The first line of the set contains two integers: the first defines the number P of the given points, and the second the number R of given routes between the points. The following R lines define the given routes between the points, each giving three integer numbers: the first two numbers identify the points, and the third gives the length of the route. The numbers are separated with white spaces. A data set giving only one number P=0 denotes the end of the input. The data sets are separated with an empty line.
The maximal number of points is 50. The maximal length of a given route is 100. The number of possible routes is unlimited. The nodes are identified with integers between 1 and P (inclusive). The routes between two points i and j may be given as i j or as j i.

Output

For each data set, print one number on a separate line that gives the total length of the cable used for the entire designed network.

Sample Input

1 0

2 3
1 2 37
2 1 17
1 2 68

3 7
1 2 19
2 3 11
3 1 7
1 3 5
2 3 89
3 1 91
1 2 32

5 7
1 2 5
2 3 7
2 4 8
4 5 11
3 5 10
1 5 6
4 2 12

0

Sample Output

0
17
16
26

题意：连通各点最短距离，最小生成树。

kruskal（克鲁斯卡尔算法） 加边法

其本质是并查集

#include //kruskal（克鲁斯卡尔算法） 加边法
#include
using namespace std;
int n,m;
int pre[100005];
struct node
{
    int u,v,w;
} edge[100005];
int cmp(node a,node b)
{
    return a.w }
int find(int x)
{
    if(x==pre[x])
        return x;
    return pre[x]=(find(pre[x]));
}
int main()
{
    int p,r;

    while(scanf("%d",&p)!=EOF)
    {
        if(p==0)
            break;
        scanf("%d",&r);
        for(int i=1;i<=p;i++)
        {
            pre[i]=i;
        }
        for(int i=1;i<=r;i++)
        {
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
        }
        sort(edge+1,edge+r+1,cmp);
        int ans=0;
        int num=0;
        for(int i=1;i<=r;i++)
        {
            int fx=find(edge[i].u);
            int fy=find(edge[i].v);
            if(fx!=fy)
            {
                pre[fx]=fy;
                ans+=edge[i].w;
                num++;
            }
            if(num==p-1)
                break;
        }
        printf("%d\n",ans);
    }
    return 0;
}

prime （普利母算法） 加点法

#include//普利母算法 加点法
#include
#define inf 0x3f3f3f3f
int p,r;
int pre[1001][1001];
int vis[1001],dis[1001];
void prim()
{
    int i,j,k;
    int idex=0;
    int ans=0;
    memset(vis,0,sizeof(vis));
    vis[1]=1;//标记数组　　若是此点走过就标记为一　　此时是将１点作为路的开头
    for(i=2; i<=p; i++)
        dis[i]=pre[1][i];//将从１到各个点的距离全部储存在dis数组中//若是两个点中没有路那么dis中储存的就是最大值inf
    for(i=2; i<=p; i++)//遍历每个点　　因为最小生成树就是要把所有的点全部遍历
    {
        int min=inf;
        idex=0;
        for(j=1; j<=p; j++)//遍历每一个点　找到一个离１最近的点
        {
            if(!vis[j] && dis[j]             {
                min=dis[j];//维护最小值
                idex=j;
            }
        }
        ans+=min;//将每一步的最小值都加在ans
        //printf("%d\n",ans);
        vis[idex]=1;//将走的点标记
        for(k=1; k<=p; k++)
            if(!vis[k] && dis[k]>pre[idex][k])//更新dis数组//其原则是从目前所在的点出发和之前存在dis中的值作比较将较小的值存起来
                dis[k]=pre[idex][k];
    }
    printf("%d\n",ans);
}

int main()
{
    int u,v,w;
    while(scanf("%d",&p,&r)!=EOF)
    {
         if(p==0)
            break;
        scanf("%d",&r);
        memset(pre,inf,sizeof(pre));//将pre数组初始化为最大值对以后计算有帮助
        for(int i=1; i<=r; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(pre[u][v]>w)
            {
                pre[u][v]=w;//将两点之间的距离正相反相全部存起来
                pre[v][u]=w;
            }
        }
        prim();//进入函数
    }

    return 0;
}