ghc很喜歡吃湯圓，但是湯圓很容易被粘(zhān)漏。

根據多年吃湯圓經驗，ghc總結出了一套湯圓防漏理論：

互相接觸的湯圓容易粘(zhān)在一起，並且接觸面積不同，粘(zhān)在一起的粘(nián)度也不同。

當ghc要夾起一個湯圓時，這個湯圓和現在碗裏與這個湯圓接觸的所有湯圓之間的粘(nián)度的和，如果大於湯圓的硬度，這個湯圓就會被粘(zhān)漏。

今天ghc又要煮湯圓啦，今天要煮個湯圓，並且擺盤的方法已經設計好：

湯圓按照編號，有對湯圓互相接觸，用表示編號為和的兩個湯圓互相接觸，粘(nián)度為。

湯圓當然是越軟越好吃，但是ghc的廚藝只允許把所有湯圓煮成同樣的硬度。那麽，湯圓的硬度最小可以是多少，可以滿足吃的過程中，存在一種夾湯圓的順序，使得沒有湯圓會被粘(zhān)漏呢？

註意：

不考慮湯圓的重力作用；

不能同時夾多個湯圓；

吃完湯圓一定要喝點湯。

Input

第一行是一個正整數，表示測試數據的組數，

對於每組測試數據，

第一行是兩個整數，

接下來行，每行包含三個整數，

同一對湯圓不會出現兩次。

Output

對於每組測試數據，輸出一行，包含一個整數，表示湯圓硬度的最小值。

Sample Input

1
4 6
1 2 2
1 3 2
1 4 2
2 3 3
2 4 3
3 4 5

Sample Output

6

#include<bits/stdc++.h>

using
 
 namespace std;

const int N = 1e5 + 5;

using LL = long long;
using P = pair<LL, int>;

LL cnt[N];
int n, m;

set<P> edge[N];

priority_queue<P, vector<P>, greater<P> > Q;

void Work(){
    LL ans = 0;
    for(int i = 1; i <= n; i++){
        Q.push({cnt[i], i});
    }
    
 
while(!Q.empty()){
        auto tmp = Q.top(); Q.pop();
        if(tmp.first != cnt[tmp.second]) continue;
        int u = tmp.second;
        ans = max(ans, tmp.first);
        for(auto p : edge[u]){
            int v = p.second;
            cnt[v] -= p.first;
            edge[v].erase({p.first, u});
            Q.push({cnt[v], v});
        }
    }
    cout << ans << endl;
}

int main(){
   int T;
   cin >> T;
   while(T--){
       cin >> n >> m;
       for(int i = 1; i <= n; i++) {
            edge[i].clear();
            cnt[i] = 0;
       }

       int u, v, w;
       for(int i = 1; i <= m; i++){
            cin >> u >> v >> w;
            cnt[u] += w;
            cnt[v] += w;
            edge[u].insert({w, v});
            edge[v].insert({w, u});
       }
       Work();
   }

}

F. 湯圓防漏理論