//
//     ░        ░           ░                   ░▒░ ░░░░░▒░░   
//   ░░         ░            ░            ░ ░▒▓▓▓▒░░   ░░░░ ░  
//  ░░          ░             ░            ▓▒░     ░░░░░░░   ░ 
// ░░           ░                          ░      ░▒▓▒▒▒▒▒░░░░░
// ░                        ░  ░▒▒▒░░▒░  ░░ ░░▒▓▓▓▒░▒▓▒▒▒▒▓▓▓▓▓
//                     ░░   ░░  ▒▒▒▒▓▓▓▒░░▓▒░▓░░░   ▒▓▓▓▓▓▓▒░  
//             ░░▒░ ░  ░▒▒░  ░▒░░▒░ ░▒▒▓▒░░▓▒▒░  ░░░▒▓▓▓▓▓▓▓▒░░
//          ░  ░▒▒░░░░░░▓▓▓▒░░░░░▒     ░▓▒░▓▓▓▒░░░░░▒▓▓▓▓▓▓▓▓▓▒
//          ░░░▒▒░ ░░▒░░▒▓▒▓▒░░▒░▒       ▒▓▒▒▓▓░░░░░▒▓▓▓▓▒▒▒░░▓
//         ░░░░▓▒░  ░░▒░░▓▒▒▒▓▒░░░ ░▒▓▓▓▓██▓▒▒▓▒░░░░▒▓▓▓▓▓░░░░▒
//  ░    ░░░░▒░▓▒    ░░▒░▒▓▒ ░▓▒▒░▓▓▒▒▓███████▓▒░░░░▒▓▓▓▓▓▓░░░░
//  ░ ░░░░░░▒▓▒▒▒      ▒ ░▒▓   ▒▓▒ ░░░ ▓█████▒▓▒░░░░▓▓░  ▒▓▒░░░
// ░░░░▒░░░░▓▓▓▒▓       ░  ░▒   ░░   ▓███████▒  ░░░▒▓▓▒░  ▓▓▒░░
// ░░░░▒░░░░▓▓▒ ▒▒  ░                 ███▓▒▒▒▒  ░░░▓▓▓▒▒  ░▓▓░░
// ░░░░▒▒░░░▓▓▒  ▓█████▓░              ▒▒   ░   ░░▒▓▒ ░░  ▒▓▓░░
// ░░▓░▒▓▒░░▒▓▒ ▓█▓░▓████                       ░▒▓▒      ▓▓▓▒░
// ░░▒ ▒▓▓▒░▒▓▓ █▒░▒█████▒                     ░▒▓▒     ░▓▓▓▓▒▒
//  ░▒ ▒▓▓▓▒▒▓▓ ▒█ ▒███▓░▒                     ░▓░    ░▒▓▓▓▓▓▒▓
//  ░░  ▒▓▓▓▓▓▓▓    ░▓░       ░                ░   ░▓▓▓▓▓█▓▓▓▓▓
//   ░░  ▓▓▓▓▓▓▓▓░                                ░▓▓▓▓▓█▓▓▓▓▓▓
//    ▒    ▓▓█▓▓█▓▓░                             ░▒▒█▓▓▓▓▓▓▓▓▓▓
//          █▓▓▓▓▓▓▓░            ░░░            ▒▒▒▒█▓▓▓▓▒▒░░░░
//           █▓▓▒▓██▓▒                       ░▒▒▒▒▓▓▓▓░        
//            ░▓▓▓▓▓█▓▒                    ░▒▒▒▒▓▓▓▓░          
//           ░▓ ░▓▓▓▓▓▓▓▓▒░              ░▒▒▒▒▓▓▓▓▓            
//          ▒▒  ░▒▓▓▒▓▓▓▓▓█▓▓▓▓▒▒░░░  ░▒▒▒▒▒▒▓▓▓▒▒             
//          ▒▒   ░▓▓▒▒▓▓███████▓▓▓▓▓██▓▓▓▒▒▒▒█▓▒▒░             
//           ▒    ▒▒▓░░▒▓██████ ▓▒░░▒▓▓▓▓▓▒▒▒▓▒▒░      ░░░     
//                  ░░░░▒▓▓█  ▒     ▒▓▒▒▒▒▒▒▒▒▒▒     ░░▒▒      
//                   ░░░░░▒▓▒ ░     ░▒▒▒▒▒▒▒▒░      ░▒▒░       
//
#include <bits/stdc++.h>
using namespace std;

template<size_t SIZE> class unionFind{
    protected:
        int64_t tree[SIZE];
        int64_t edge[SIZE];
    public:
        unionFind(){
            for(int i=0;i<SIZE;i++){
                tree[i]=-1;
                edge[i]=0;
            }
        }
        uint64_t root(uint64_t a){
            assert(a < SIZE);
            if(tree[a] < 0) return a;
            else{
                uint64_t r = root(tree[a]);
                return tree[a] = r;
            }
        }
        uint64_t vcount(uint64_t a){
            return -tree[root(a)];
        }
        uint64_t ecount(uint64_t a){
            return edge[root(a)];
        }
        bool merge(uint64_t a, uint64_t b){
            a = root(a);  b = root(b);
            if(a == b){
                edge[a]++;
                return false;
            }
            if(tree[a] > tree[b]){
                swap(a, b);
            }
            edge[a] += edge[b] + 1;
            tree[a] += tree[b];
            tree[b] = a;
            return true;
        }
        bool isSame(uint64_t a, uint64_t b){
            return root(a) == root(b);
        }
};

int main(){
    int n, h, w;
    cin >> n >> h >> w;

    vector<pair<int,pair<int,int>>> edges;
    for(int i=0;i<n;i++){
        int r, c, a;
        cin >> r >> c >> a;
        edges.push_back({a, {r-1, c-1}});
    }
    sort(edges.begin(), edges.end(), greater<decltype(edges[0])>());
    int64_t ans = 0;
    unionFind<200000> uf;

    for(auto e: edges){
        const int &A = e.first, &from = e.second.first, to = e.second.second + 100000;
        if(uf.isSame(from, to)){
            if(uf.vcount(from) > uf.ecount(from)){
                uf.merge(from, to);
                ans += A;
            }
        }else{
            if(uf.vcount(from)+uf.vcount(to) > uf.ecount(from)+uf.ecount(to)){
                uf.merge(from, to);
                ans += A;
            }
        }
    }

    cout << ans << endl;
    
    return 0;
}

Measured memory_bytes: 4724