#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
using namespace std;

using ll = long long;
using ld = long double;

#define int ll
#define sz(x) ((int)(x).size())

using pii = pair<int,int>;
using tii = tuple<int,int,int>;

const int nmax = 5e4 + 5, inf = 1e9 + 6;

vector<pii> g[nmax];
int color[nmax];

void fill(int node, int C) {
   if(color[node] != 0) return;
   color[node] = C;
   //cerr << node << ' ' << C << '\n';
   for(auto [x, w] : g[node]) fill(x, C);
}

namespace DSU {
   int dsu[nmax], links[nmax];
   int cc, totalK;
   ll stdcost, supra;
   
   vector<tii> stundo;
   
   void init(int n) {
      cc = n;
      stdcost = 0;
      for(int i = 1; i <= n; i++) dsu[i] = -1, links[i] = 0;
      return;
   }
   int f(int x) { return dsu[x] < 0? x : f(dsu[x]); }
   bool unite(int x, int y) {
      x = f(x);
      y = f(y);
      if(x == y) {
         stundo.emplace_back(x, y, 0);
         return 0;
      }
      
      if(-dsu[x] < -dsu[y]) swap(x, y);
      
      stundo.emplace_back(x, y, dsu[y]);
      dsu[x] += dsu[y];
      dsu[y] = x;
      links[x] += links[y];
      cc--;
      
      return 1;
   }
   
   void addlink(int node, int aggr) {
      links[node] += aggr;
      if(dsu[node] < 0) { totalK += aggr; return; }
      addlink(dsu[node], aggr);
   }
   
   bool undo() {
      auto [x, y, A] = stundo.back();
      stundo.pop_back();
      if(x == y) return 0;
      dsu[y] = A;
      dsu[x] -= A;
      links[x] -= links[y];
      cc++;
      return links[x] == 0 || links[y] == 0;
   }
}

namespace PQ_Undo {
   set<pii> bypri;
   vector<pair<pii, int>> st;
   vector<int> pos_inst, atrpri;
   vector<pii> atrupd;
   
   void push(pii upd, int pri) {
      atrpri.emplace_back(pri);
      atrupd.emplace_back(upd);
      
      DSU::unite(upd.first, upd.second);
      st.emplace_back(make_pair(upd, sz(pos_inst)));
      pos_inst.emplace_back(sz(st) - 1);
      
      bypri.emplace(make_pair(pri, sz(pos_inst) - 1));
   }
   
   bool pop(pii THEUPD) {
      int k = sz(st), last_priority, first_priority = -1;
      
      vector<pair<pii, int>> big, small;
      
      auto it = bypri.begin();
      for(int qt = 1, lol = 0; !lol || qt < (sz(st) + 1) / 2; lol = 1, qt++) {
         int individ = it -> second;
         
         k = min(pos_inst[individ], k);
         /* if(qt > 1) */ big.emplace_back(make_pair(atrupd[individ], individ));
         last_priority = atrpri[individ];
         if(first_priority == -1) first_priority = atrpri[individ];
         
         if(qt * 2 > sz(st) - k) break;
         it++;
      }
      
      bypri.erase(bypri.begin());
      
      //cerr << sz(st) << ' ' << sz(DSU::stundo) << '\n';
      
      while(sz(st) > k) {
         auto [upd, individ] = st.back();
         
         st.pop_back();
         DSU::undo();
         
         if(atrpri[individ] > last_priority) small.emplace_back(make_pair(upd, individ));
      }
      
      copy(rbegin(big), rend(big), back_inserter(small));
      
      for(auto [upd, individ] : small) {
         DSU::unite(upd.first, upd.second);
         st.emplace_back(make_pair(upd, individ));
         
         pos_inst[individ] = sz(st) - 1;
      }
      assert(atrpri[st.back().second] != inf);
      assert(atrpri[st.back().second] == first_priority);
      assert(atrupd[st.back().second] == THEUPD);
      st.pop_back();
      
      
      return DSU::undo();
   }
}

signed main() {
   cin.tie(0) -> sync_with_stdio(0);
   int n, m, k, s;
   cin >> n >> m >> k >> s;
   
   vector<tii> edgs;
   
   for(int i = 0, x, y, w; i < m; i++) {
      cin >> x >> y >> w;
      if(y == s) swap(x, y);
      else if(x != s && x > y) swap(x, y);
      edgs.emplace_back(x, y, w);
   }
   
   pii prv = {-1, -1};
   sort(all(edgs));
   
   vector<tii> nvedgs;
   
   for(auto [x, y, w] : edgs) {
      if(prv == make_pair(x, y) && x == s) continue;
      g[x].emplace_back(y, w);
      g[y].emplace_back(x, w);
      prv = pii{x, y};
      nvedgs.emplace_back(x, y, w);
   }
   
   edgs = move(nvedgs);
   
   {
      color[s] = -1;
      int C = 1;
      for(int i = 1; i <= n; i++) {
         if(color[i] == 0) fill(i, C++);
      }
      C--;
      
      if(sz(g[s]) < k) {
         cout << "nonnondayo\n";
         return 0;
      }
      if(!([&]() {
         vector<int> found_colors(C, 0);
         for(auto [x, w] : g[s]) found_colors[color[x] - 1] = 1;
         if((accumulate(all(found_colors), 0) != C) || C > k) return false;
         return true;
      }())) {
         cout << "nonnondayo\n";
         return 0;
      }
   }
   
   DSU::init(n);
   DSU::cc--;
   
   sort(all(edgs), [&](auto a, auto b) { return get<2>(a) < get<2>(b); });
   
   for(auto [x, w] : g[s]) {
      DSU::addlink(x, 1);
   }
   
   vector<tii> keeper;
   
   int II = sz(edgs) + 2;
   int cock = inf;
   
   for(auto [a, b, w] : edgs) {
      //cout << a << ' ' << b << ' ' << w << '\n';
      if(a == s) continue;
      PQ_Undo::push(pii{a, b}, II);
      II--;
   }
   
   for(int i = sz(edgs) - 1; i >= 0; i--) {
      auto [a, b, w] = edgs[i];
      if(a != s) {
            //cerr << DSU::cc << '\n';
         if(PQ_Undo::pop(pii{a, b}) || DSU::cc > k) {
            
            //cerr << DSU::cc << '\n';
            keeper.emplace_back(edgs[i]);
            PQ_Undo::push(pii{a, b}, cock);
            cock++;
            //cerr << DSU::cc << '\n';
            //assert(DSU::cc <= k);
            //while(sz(DSU::stundo)) DSU::undo();
            //for(auto [u, v, T] : keeper) if(u != s) DSU::unite(u, v);
            //for(auto [u, v, T] : edgs | views::take(i)) if(u != s) DSU::unite(u, v);
         }
      }
      else {
         if(DSU::links[DSU::f(b)] == 1 || DSU::totalK == k)
            //cerr << a << ' ' << b << ' ' << w << '\n',
            keeper.emplace_back(edgs[i]);
            //k--;
         else
            DSU::addlink(b, -1);
      }
   }
   
   //cerr << sz(keeper) << '\n';
   
   ll total = 0;
   for(auto [a, b, w] : keeper) {
      total += w;
      //cout << a << ' ' << b << '\n';
   }
   
   cout << total << '\n';
}

/**
      Istenem! Nu poate fi real.
-- Surse verificate
*/