HDU 1863 畅通工程 最小生成树

思路：

                   比较典型的最小生成树的题目了、、在这里用求最小生成树的经典算法K(Kruskal)算法和P（Prim）算法。我的 K 算法用的是结构体来存图，P 算法用的是邻接矩阵来存图，K算法的复杂度是O(ElogE)，比较适用于稀疏图，P算法的复杂的是O（V ^ 2）,适合用稠密图。

以下是C++的K算法代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <algorithm>
using namespace std;

const int MAXN = 2e3+ 3;
int pre[MAXN];
int m,n;

int Find(int x)  //并查集
{
    return x == pre[x] ? x :(pre[x] = Find(pre[x]));
}

struct Node //存图
{
    int u, v, w;
}cy[103];

int mycmp(Node a,Node b)
{
    return a.w < b.w;
}

void mst()
{
    for(int i = 0 ; i < 102; i++)
        pre[i] = i;
}

int kru()//算法的具体实现
{
    int ans = 0;
    int cnt = 0;
    for(int i = 1; i <= n; i++)
    {
        int fv = Find(cy[i].v);
        int fu = Find(cy[i].u);
        if(fv != fu)
        {
            pre[fv] = fu;
            ans += cy[i].w;
            cnt ++;
        }
        if(cnt == m -1)
        {
            return ans;
            break;
        }
    }
    return -1;
}

int main()
{
    //freopen("in.cpp","r",stdin);
    while(~scanf("%d%d",&n,&m) && n)
    {
        mst();
        for(int i = 1; i <= n; i++)
            scanf("%d%d%d",&cy[i].u, &cy[i].v, &cy[i].w);
        sort(cy + 1, cy + n + 1, mycmp);
        int ans = kru();
        if(ans != -1)
            printf("%d\n",ans);
        else
            printf("?\n");
    }
    return 0;
}

以下是C++的P算法代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <algorithm>
using namespace std;

const int MAXN = 103;
const int INF = 0x3f3f3f3f;
int edge[MAXN][MAXN];   //用于存放图
int used[MAXN];//用于标记点是否已加入到最小生成树那个的集合中
int lowcost[MAXN];   //用于存放集合外的点到集合内的点的最短距离，每加入一个点需要更新一次
int N,M;

int prim(int start,int maxn)  //利用prim算法计算最小生成树
{
   memset(used, 0, sizeof(used));
   for(int i = 1; i <= maxn; i++)
   {
       lowcost[i] = edge[start][i];
   }
   used[start] = 1;
   int sumweight = 0;
   int ok = 0;
   for(int i = 1; i <= maxn; i++)
   {
       int minn = INF ;
       int v = -1;
       for(int j = 1; j <= maxn; j++)
       {
           if(used[j] == 0 && lowcost[j] < minn)
           {
               minn = lowcost[j];
               v = j;
           }
       }
       //cout << v << " ";
       if(v != -1)
       {
           ok++;
           used[v] = 1;
           sumweight += lowcost[v];
           for(int j = 1; j <= maxn; j++)
           {
               if(used[j] == 0 && lowcost[j] > edge[v][j])
               {
                   lowcost[j] = edge[v][j];
               }
           }
       }
   }
   if(ok == maxn -1)
     return sumweight;
   return -1;
}

int main()
{
    while(cin >> N >> M && N)
    {
        memset(edge, 0x3f, sizeof(edge));
        while(N--)
        {
            int u, v, w;
            cin >> u >> v >> w;
            edge[u][v] = edge[v][u] = w;
        }
        int ans = prim(1, M);
        if(ans < 0) cout << "?" <<endl;
        else cout << ans << endl;
    }
    return 0;
}

以下是JAVA的K算法

import java.util.Scanner;
import java.util.Comparator;
import java.util.Arrays;
import java.text.DecimalFormat;

class Vge{
	int u;
	int v;
	int w;
}

class mycmp implements  Comparator<Vge>{
	public int compare( Vge A, Vge B ){  
	        if( A.w - B.w != 0 )   
	        	return A.w - B.w;  
	        else 
	        	return A.w - B.w;  
	  }  
}

public class Main{
	final static int MAXN = 100 + 3;
	static int[] pre = new int[ MAXN ];
	static Vge[] clg = new Vge[ MAXN * MAXN ];
	public static void main( String[] args ){
		Scanner sc = new Scanner( System.in );
		int n, m;
		while( sc.hasNextInt() ){
			n = sc.nextInt();
			m = sc.nextInt();
			if( n == 0 ) break;
			for( int i = 0; i < n; i++ ){
				clg[ i ] = new Vge();
				clg[ i ].u = sc.nextInt();
				clg[ i ].v = sc.nextInt();
				clg[ i ].w = sc.nextInt();
			}
			mst( m );
			int ans = ksu( n, m );
			if( ans == -1 ) System.out.println( "?" );
			else System.out.println( ans );
		}
		sc.close();
	}
	public static void mst( int n ){
		for( int i = 0; i <= n; i++ ){
			pre[i] = i;
		}
	}
	public static int find( int x ){
		return x == pre[ x ] ?   x :  ( pre[ x ] = find( pre[ x ] ) );
	}
	public static int ksu( int n, int m ){
		Arrays.sort( clg, 0, n, new mycmp() );
		int cnt = 0;
		int ans = 0;
		for( int i = 0; i < n; i++ ){
			int fu = find( clg[ i ].u );
			int fv = find( clg[ i ].v );
			if( fu != fv ){
				ans += clg[i].w;
				cnt ++;
				pre [ fv ] = fu;
			}
			if( cnt == m - 1 ) return ans;
		}
		return -1;
	}
}