C :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define maxn 2010
#define maxv 10010

struct edge{
int u, v;
int cost;
}E[maxv];

int f[maxn];
int n, m, cnt;

int find(int v){
if(f[v] == v)return v;
int F = find(f[v]);
f[v] = F;
return F;
}


int cmp(const void *a, const void * b){
return (*(struct edge *)a).cost - (*(struct edge *)b).cost;
}

int Kruskal(int Num_edge){
int ans = 0;
qsort(E,cnt,sizeof(struct edge),cmp);
for(int i = 0;i < cnt; i++){
    if(Num_edge == n - 1)break;
    int fu = find(E[i].u);
    int fv = find(E[i].v);
    if(fu != fv){
        f[fu] = fv;
        ans += E[i].cost;
        Num_edge++;
    }
}
return ans;
}

int main()
{
    while(scanf("%d%d",&n,&m) != EOF){
        int ans = 0, Num_edge = 0;
        cnt = 0;
        for(int i = 0;i <= n; i++)f[i] = i;
        for(int i = 0;i < m; i++){
            int a, b, c, d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            if(a == 1){
                ans += d;
                int fb = find(b);
                int fc = find(c);
                if(fb != fc){
                        f[fb] = fc;
                        Num_edge++;
                }
            }
            if(a == 2){
                E[cnt].u = b;
                E[cnt].v = c;
                E[cnt].cost = d;
                cnt++;
            }
        }
        printf("%d\n",Kruskal(Num_edge)+ans);
    }
    return 0;
}

C++ :

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

using namespace std;

typedef struct tagTrack
{
	int m_kind;
	int m_x;
	int m_y;
	int m_weight;
}TRACK, *PTRACK;

void InitData(PTRACK& pTrack, const int& nTrack);
int CalcRes(PTRACK& pTrack, const int& nAdmin, const int& nTrack);
int comp(const TRACK& a, const TRACK& b);
int FindRoot(int*& pRoot, const int& x);

int main()
{
	int nAdmin = 0, nTrack = 0;
	PTRACK pTrack = NULL;

	cin >>nAdmin >>nTrack;
	InitData(pTrack, nTrack);
	cout <<CalcRes(pTrack, nAdmin, nTrack);
	
	delete []pTrack;
	pTrack = NULL;
	return 0;
}

void InitData(PTRACK& pTrack, const int& nTrack)
{
	pTrack = new TRACK[nTrack + 1];
	memset(pTrack, 0, (nTrack+1)*sizeof(TRACK));
	
	for (int i = 0; i < nTrack; ++i)
	{
		cin >>pTrack[i].m_kind >>pTrack[i].m_x >>pTrack[i].m_y >>pTrack[i].m_weight;
	}
}

int CalcRes(PTRACK& pTrack, const int& nAdmin, const int& nTrack)
{
	int nWeight = 0;
	int k = 0, i = 0;
	int rx = 0, ry = 0;
	int* pRoot = new int[nAdmin + 1];
	for (int i = 0; i <= nAdmin; ++i) pRoot[i] = i;
	
	sort(pTrack, pTrack + nTrack, comp);
	while (k < nAdmin - 1)
	{
		rx = FindRoot(pRoot, pTrack[i].m_x);
		ry = FindRoot(pRoot, pTrack[i].m_y);
		if (rx != ry)
		{
			pRoot[rx] = ry;
			nWeight += pTrack[i].m_weight;
			++k;
		}
		else if (pTrack[i].m_kind == 1)
		{
			nWeight += pTrack[i].m_weight;
		}
		++i;
	}
	
	delete []pRoot;
	pRoot = NULL;
	return nWeight;
}

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

int comp(const TRACK& a, const TRACK& b)
{
	if (a.m_kind == b.m_kind) return a.m_weight < b.m_weight;
	return a.m_kind < b.m_kind;
}