#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;
   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) {
      //auto [a, b] = make_pair(x, y);
      x = f(x);
      y = f(y);
      //cerr << x << ' ' << y << '\n';
      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) 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 1;
   }
}

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;
   for(auto [a, b, w] : edgs) {
      if(a == s) continue;
      DSU::unite(a, b);
   }
   
   for(int i = sz(edgs) - 1; i >= 0; i--) {
      auto [a, b, w] = edgs[i];
      //cerr << a << ' ' << b << '\t' << DSU::cc << '\n';
      if(a != s) {
         DSU::undo();
         if(DSU::cc > k) {
            keeper.emplace_back(edgs[i]);
            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)
            keeper.emplace_back(edgs[i]),
            k--;
         else
            DSU::addlink(b, -1);
      }
   }
   
   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
*/