#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 {
   vector<int> neigh[nmax];
   
   int dsu[nmax];
   int atrS[nmax];
   int sum[nmax];
   int cc, k;
   ll stdcost, supra;
   void init(int n, int D, int k) {
      cc = D;
      stdcost = 0;
      supra = 0;
      for(int i = 1; i <= n; i++) dsu[i] = i, atrS[i] = inf, sum[i] = 0;
      return;
   }
   int f(int x) { return dsu[x] == x? x : dsu[x] = f(dsu[x]); }
   bool unite(int x, int y, int w) {
      x = f(x);
      y = f(y);
      if(x == y) {
         return 0;
      }
      
      if(atrS[x] != inf && atrS[y] != inf) {
         if(cc <= k) return 0;
         cc--;
      }
      
      //cerr << x << ' ' << y << '\t' << atrS[x] << ' ' << atrS[y] << '\t' << cc << ' ' << k << '\n';
      
      if(atrS[x] > atrS[y]) swap(x, y);
      
      sum[x] += sum[y];
      sum[x] += w;
      dsu[y] = x;
      
      return 1;
   }
   
   int extract(int x) {
      x = f(x);
      for(auto& a : neigh[x])
         a = f(a);
      sort(all(neigh[x]), [&](int a, int b) { return atrS[a] > atrS[b]; });
      while(sz(neigh[x])) {
         auto b = neigh[x].back();
         neigh[x].pop_back();
         if(f(b) == x) continue;
         return b;
      }
      return -1;
   }
}

signed main() {
   cin.tie(0) -> sync_with_stdio(0);
   int n, m, k, s;
   cin >> n >> m >> k >> s;
   DSU::k = k;
   
   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));
   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};
   }
   
   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;
   }
   
   sort(all(g[s]), [&](auto a, auto b) { return a.second < b.second; });
   vector<int> occ(C + 1, 0);
   
   DSU::init(n, sz(g[s]), k);
   int mxS = -1;
   for(auto [x, w] : g[s]) {
      DSU::atrS[x] = w;
   }
   
   for(int i = 0; i < sz(edgs); i++) {
      if(get<0>(edgs[i]) == s) {
         swap(edgs[i], edgs.back());
         edgs.pop_back();
         i--;
      }
   }
   
   
   sort(all(edgs), [&](auto a, auto b) { return get<2>(a) < get<2>(b); });
   int lastw = -1;
   
   auto process = [&](vector<tii>& candidates) {
      using namespace DSU;
      int C = -1;
      vector<int> CD;
      for(auto [x, y, w] : candidates) {
         C = w;
         x = f(x);
         y = f(y);
         if(x == y) continue;
         neigh[x].emplace_back(y);
         neigh[y].emplace_back(x);
         CD.emplace_back(x);
         CD.emplace_back(y);
      }
      
      if(C == -1) return;
      
      assert(sz(CD) <= 2);
      
      sort(all(CD)); CD.erase(unique(all(CD)), end(CD));
      sort(all(CD), [&](int a, int b) { return atrS[a] < atrS[b]; });
      for(int i = sz(CD) - 1; i >= 0; i--) {
         auto b = extract(CD[i]);
         if(b == -1) continue;
         unite(CD[i], b, C);
      }
      
      for(auto x : CD) neigh[x].clear();
      
   };
   
   vector<tii> candidates;
   for(auto [x, y, w] : edgs) {
      //cerr << x << ' ' << y << ' ' << w << '\n';
      if(w != lastw) {
         //cerr << lastw << '\n';
         process(candidates);
         candidates.clear();
      }
      lastw = w;
      candidates.emplace_back(x, y, w);
   }
   process(candidates);
   
   
   ll total = 0;
   for(int i = 1; i <= n; i++) {
      if(i == s) continue;
      if(DSU::f(i) == i) total += DSU::sum[i] + DSU::atrS[i];
   }
   
   cout << total << '\n';
}

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