7-10 公路村村通 (30分)--最小生成树prim

思路：先用顶点0建立最小生成树，此时生成树有0一个顶点，树到其余顶点的权则为0到各点的权，然后循环：找到lowcost[]的最小值，将其对应顶点纳入最小生成树。设为顶点a，然后判断a到其余各顶点的权是否小于lowcost[]中对应的值，如果小于，则更新lowcost[]的值（即此时最小生成树到其余顶点的最小权），然后进入下一循环。

1.建立adjvex[ ]用于存储纳入最小生成树的顶点，建立lowcost[ ]用于存储边的权值。

2.从顶点0开始，lowcost[i]置为arc[0][i]。

3.初始化完成，开始进行循环。从1开始，逐步确立adjvex[i]的值，即确立在最小生成树中的顶点。

4.找到lowcost[]中的最小值，假设最终最小值lowcost[j],则用k记录下j值。然后将adjvex[i]置为k（这里将k顶点纳入了生成树），lowcost[k]置0（即k已在生成树中，当然到树的距离为0，为0时表示以后不用再处理）。

5.k到生成树外j顶点的权若小于lowcost[j]，则更新lowcost[j]为arc[k][j]。

6.到这里，一次循环结束，确定了adjvex[i]的值，也为下一次循环更新了lowcost[]的值（每一次新循环开始，lowcost[]的值都是前一步的最小生成树到各顶点最小权值）。

#include <iostream>
#include <string>
#define MAX 1001
#define INFINITY 65535

using namespace std;

struct GNode
{
    int V, W;
    int G[MAX][MAX];
};
typedef struct GNode* gptr;
gptr g = new struct GNode;
int Count = 1;
bool f[MAX] = { false };
void dfs(int i);
int main()
{
    int mon = 0;
    int V, W;
    int adj[MAX] = { 0 };
    int low[MAX] = { 0 };
    cin >> V >> W;
    g->V = V; g->W = W;
    if (g->V-1 > g->W)
    {
        cout << "-1";return 0;
    }
    for (int i = 1; i <= g->V; i++)
        for (int j = 1;j <= g->V; j++)
            g->G[i][j] = g->G[j][i] = INFINITY;
    for (int i = 1; i <= g->W; i++)
    {
        int c1, c2, temp;
        cin >> c1 >> c2 >> temp;
        g->G[c1][c2] = g->G[c2][c1] = temp;
    }
    dfs(1);
    if (Count != g->V)
    {
        cout << "-1";
        return 0;
    }
    for (int i = 1;i <= g->V; i++)
    {
        low[i] = g->G[1][i];
    }
    adj[1] = 1;
    low[1] = 0;
    for (int i = 2; i <= g->V; i++)
    {
        int j = 2;int k = 0;
        int min = INFINITY;
        while (j <= g->V)
        {
            if (low[j]!=0 && low[j] < min)
            {
                min = low[j];
            //    low[j] = k;
                k = j;
            }
        
            j++;
        }
        mon += min;
        low[k] = 0;
        adj[i] = k;
        for (int j = 1; j <= g->V; j++)
        {
            if (low[j]!=0 && g->G[k][j] < low[j])
            {
                low[j] = g->G[k][j];

            }
        }
    }
    
    cout << mon;
    return 0;
}
void dfs(int i)
{
    for (int j = i+1; j <= g->V; j++)
    {
        
        if (g->G[i][j] != INFINITY)
        {
            if (!f[j])
            {
                f[j] = true;
                dfs(j);
                Count++;
            }
        }
        if (j == g->V) return;
    }

    return;
}