online_judge_1249

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <limits>

using namespace std;

const int M = 100100;
const int N = 1005;

struct E
{
int s;
int e;
int cost;
bool operator < (const E &e) const
{
return cost < e.cost;
}
};

int Kruskal(E *edge, int m, int *id, int *Tree, int n);
int findRoot(int *Tree, int x);
int SecondTree(E *edge, int pos, int *Tree, int m, int n);

int main()
{
int id[M];
int Tree
;
E edge[M];
int t,n,m,i;
int res,r;
cin>>t;
while(t--)
{
res = -1;
cin>>n>>m;
for(i=0; i<m; ++i)
{
cin>>edge[i].s>>edge[i].e>>edge[i].cost;
}
sort(edge, edge+m);
res = Kruskal(edge, m, id, Tree, n);
if(res == -1)
{
cout<<-1<<endl;
continue;
}
res = numeric_limits<int>::max();
for(i=0; i<n-1; ++i)
{
r = SecondTree(edge, id[i], Tree, m, n);
if(r!=-1 && r<res)
res = r;
}
if(res == numeric_limits<int>::max())
cout<<-1<<endl;
else
cout<<res<<endl;
}
return 0;
}

int findRoot(int *Tree, int x)
{
if(Tree[x]==-1)
return x;
else
{
int tmp = findRoot(Tree, Tree[x]);
Tree[x] = tmp;
return tmp;
}
}

int Kruskal(E *edge, int m, int *id, int *Tree, int n)
{
int a,b,i,cnt = 0,res = 0;
for(i=0; i<N; ++i)
{
Tree[i] = -1;
}
for(i=0; i<m; ++i)
{
if(cnt == n-1)
break;
a = findRoot(Tree, edge[i].s);
b = findRoot(Tree, edge[i].e);
if(a!=b)
{
Tree[a] = b;
id[cnt++] = i;
res += edge[i].cost;
}
}
if(cnt != n-1)
return -1;
return res;
}

int SecondTree(E *edge, int pos, int *Tree, int m, int n)
{
int a,b,i,cnt = 0,res = 0;
for(i=0; i<N; ++i)
{
Tree[i] = -1;
}
for(i=0; i<m; ++i)
{
if(cnt == n-1)
break;
if(i == pos)
continue;
a = findRoot(Tree, edge[i].s);
b = findRoot(Tree, edge[i].e);
if(a!=b)
{
Tree[a] = b;
cnt++;
res += edge[i].cost;
}
}
if(cnt!=n-1)
return -1;
return res;
}

/*实在是不知道为什么这种做法提交总是错误……
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <limits>

using namespace std;

const int N = 101;

struct E
{
int next;
int cost;
bool operator < (const E &e) const
{
return cost < e.cost;
}
};

int minSecTree(int *a, int n, vector<E> *edge, bool *mark, int v);

int main()
{
int a
;
bool mark
;
vector<E> edge
;
int t,n,m,i,j;
int s,e,w;
int res;
cin>>t;
while(t--)
{
res = -1;
cin>>n>>m;
for(i=0; i<=n; ++i)
{
edge[i].clear();
}
for(i=0; i<m; ++i)
{
cin>>s>>e>>w;
E tmp;
tmp.cost = w;
tmp.next = e;
for(j=0; j<edge[s].size(); ++j) //去除重边
{
if(edge[s][j].next == e)
continue;
}
edge[s].push_back(tmp);
tmp.next = s;
edge[e].push_back(tmp);
}
for(i=1; i<=n; ++i)
sort(edge[i].begin(), edge[i].end());
for(i=1; i<=n; ++i)
{
if(minSecTree(a,n,edge,mark,i)!=-1 && (res==-1 || minSecTree(a,n,edge,mark,i)<res))
res = minSecTree(a,n,edge,mark,i);
}
cout<<res<<endl;
}
return 0;
}

int minSecTree(int *a, int n, vector<E> *edge, bool *mark, int v)
{
int i,j,numE = 0,res = 0;
int mm, mindex;
if(edge[v].size() <= 1)
return -1;
memset(mark, false, sizeof(mark));
for(i=1; i<=n; ++i)
{
a[i] = numeric_limits<int>::max();
}
a[v] = 0;
for(i=1; i<edge[v].size(); ++i)
{
a[edge[v][i].next] = edge[v][i].cost;
}
mark[v] = true;
res += edge[v][1].cost;
numE++;
v = edge[v][1].next;
mark[v] = true;
for(i=1; i<n-1; ++i)
{
for(j=0; j<edge[v].size(); ++j)
{
if(mark[edge[v][j].next]==false && edge[v][j].cost<a[edge[v][j].next])
a[edge[v][j].next] = edge[v][j].cost;
}
mm = numeric_limits<int>::max();
mindex = -1;
for(j=0; j<n; ++j)
{
if(mark[j]==false && a[j]<mm)
{
mm = a[j];
mindex = j;
}
}
res += mm;
numE++;
if(mindex == -1)
return -1;
v = mindex;
mark[v] = true;
}
if(numE == n-1)
return res;
return -1;
}
*/