C :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define maxn 310
#define INF 1000000000

int G[maxn][maxn];
int d[maxn];
int vis[maxn];
int n, m;

int prime(){
for(int i = 1;i <= n; i++)d[i] = INF;
memset(vis,0,sizeof(vis));
d[1] = 0;
int ans = 0;
for(int i = 1;i <= n; i++){
    int u = -1, MIN = INF;
    for(int j = 1;j <= n; j++){
        if(MIN > d[j] && vis[j] == 0){
            u = j;
            MIN = d[j];
        }
    }
    if(ans < MIN) ans = MIN;
    vis[u] = 1;
    for(int v = 1;v <= n; v++){
        if(vis[v] == 0 && G[u][v] != 0 && d[v] > G[u][v]){
            d[v] = G[u][v];
        }
    }
}
return ans;
}

int main()
{
    while(scanf("%d%d",&n,&m) != EOF){
        memset(G,0,sizeof(G));
        for(int i = 1;i <= m; i++){
            int a, b, c;
            scanf("%d%d%d",&a,&b,&c);
            G[a][b] = G[b][a] = c;
        }
        printf("%d %d\n",n-1,prime());
    }
    return 0;
}

C++ :

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef struct tagRoad
{
	int m_crossx;
	int m_crossy;
	int m_weight;
} ROAD, *PROAD;

int comp(const ROAD& a, const ROAD& b);
void InitData(PROAD& pRoad, const int& nCross, const int& nRoad);
int KrusMST(PROAD& pRoad, const int& nCross);
int FindRoot(int*& pRoad, const int& x);

int main()
{
	int nCross = 0, nRoad = 0;
	// Kruskal算法
	PROAD pRoad = NULL; // 边信息
	
	// 初始化数据
	cin >>nCross >>nRoad;
	InitData(pRoad, nCross, nRoad);
	
	// Kruskal算法求最小生成树
	cout <<nCross -1 <<' ' <<KrusMST(pRoad, nCross);
	
	delete []pRoad;
	pRoad = NULL;
	return 0;
}

void InitData(PROAD& pRoad, const int& nCross, const int& nRoad)
{
	pRoad = new ROAD[nRoad + 1];
	//pRoot = new int[nCross + 1];
	memset(pRoad, 0, (nRoad+1)*sizeof(ROAD));
	//for (int i = 0; i <= nCross, ++i) pRoot[i] = i;
	
	for (int i = 0; i < nRoad; ++i)
	{
		cin >>pRoad[i].m_crossx >>pRoad[i].m_crossy >>pRoad[i].m_weight;
	}
	sort(pRoad, pRoad + nRoad, comp);
}

int comp(const ROAD& a, const ROAD& b)
{
	return a.m_weight < b.m_weight;
}

int KrusMST(PROAD& pRoad, const int& nCross)
{
	int nEdge = 0; // 边的个数
	int x = 0, y = 0, weight = 0;
	int k = 0; // 边的增量
	int* pRoot = new int[nCross + 1];
	for (int i = 0; i <= nCross; ++i) pRoot[i] = i;
	
	while (nEdge < nCross - 1)
	{
		x = FindRoot(pRoot, pRoad[k].m_crossx);
		y = FindRoot(pRoot, pRoad[k].m_crossy);
		if (x != y)
		{
			pRoot[x] = y;
			++nEdge;
			weight = pRoad[k].m_weight;
		}
		++k;
	}

	delete []pRoot;
	pRoot = NULL;
	return weight;
}

int FindRoot(int*& pRoad, const int& x)
{
	if (pRoad[x] != x) pRoad[x] = FindRoot(pRoad, pRoad[x]);
	return pRoad[x];
}

Pascal :

program wtd;
type
 list=record
  frontv,endv,w:longint;
  end;
var
 n,i,j,s,k,p,min,m,u,v,max:longint;
 a:array[1..300,1..300]of longint;
 c:array[1..10000]of list;
 t:list;
procedure prim;
begin
 for i:= 1 to n-1 do
  begin
   c[i].frontv:=1;
   c[i].endv:=i+1;
   c[i].w:=a[c[i].frontv,c[i].endv];
  end;
 for k:= 1 to n-1 do
  begin
   min:=maxint;
   for i:=k to n-1 do
    if min>c[i].w then
     begin
      min:=c[i].w;
      p:=i;
     end;
   t:=c[p]; c[p]:=c[k]; c[k]:=t;
   j:=c[k].endv;
   for i:= k+1 to n-1 do
    begin
     if a[j,c[i].endv]<c[i].w then
      begin
       c[i].w:=a[j,c[i].endv];
       c[i].frontv:=j;
      end;
    end;
  end;
end;

begin
 readln(n,m);
 for i:= 1 to m do
   begin
    read(u,v);
    read(a[u,v]);
    a[v,u]:=a[u,v];
   end;
  for i:= 1 to n do
   for j:= 1 to n do
    if (i<>j)and(a[i,j]=0) then a[i,j]:=maxint;
   prim;
   write(n-1,' ');
   max:=0;
 {for i:= 1 to n-1 do
  begin
   write(c[i].w);
  end;            }
 for i:= 1 to n-1 do
  if c[i].w>max then max:=c[i].w;
  writeln(max);
end.