#include <cstring>
 
bool G[N][N];
int n,m;
memset(G,-1,sizeof(G));
cin>>n>>m;
int u,v,w;//weight
for(int i=0;i<m;++i){
    cin>>u>>v>>w;
    G[u][v]=w;
}

#include <vector>
 
vector<int> G[N];
int n,m;
cin>>n>>m;
int u,v;
for(int i=0;i<m;++i){
    cin>>u>>v;
    G[u].push_back(v);
}

#include <vector>
#include <utility>
#define pii pair<int,int>
 
vector<pii> G[N];
int n,m;
cin>>n>>m;
int u,v,w;
for(int i=0;i<m;++i){
    cin>>u>>v>>w;
    G[u].push_back({v,w});
    G[v].push_back({u,w});
}

struct E{
    int v,w;
};
vector<E> G[N];
//input
G[u].push_back({v,w});
//枚舉一個點連出去的邊
for(auto [v,w]:G[u])

vector<int> G[N];
bool vis[N];
void dfs(int cur){//current
    vis[cur]=1;
    for(int nxt:G[cur]){//next
    	if(vis[nxt])continue;
        dfs(nxt);
    }
}
int main(){
    for(int i=0;i<n;++i){
    	if(!vis[i])dfs(i);
    }
}

vector<int> G[N];
bool vis[N];
void dfs(int cur,int fa){//current, father
    for(int nxt:G[cur]){//nxt
    	if(nxt==fa)continue;
        dfs(nxt,cur);
    }
}
int main(){
    //根是1的連通樹
    dfs(1,1);
}

#include <vector>
#include <queue>
 
queue<int> Q;
vector<int> G[N];
for(int i=0;i<n;++i){
    //i作為起點
    if(vis[i])continue;
    Q.push(i);
    while(!Q.empty()){
    	int cur=Q.front();Q.pop();
        for(int nxt:G[cur]){
            if(vis[nxt])continue;
            Q.push(nxt);
        }
    }
    //Q必是空的
}

#define pii pair<int,int>
vector<pii> G[N];
int dis[N];
//Bellman-Ford，起點1
fill(dis,dis+n+1,INF);
dis[1]=0;
for(int t=1;t<n;++t){
    for(int u=1;u<=n;++u){
        for(auto [v,d]:G[u]){
            dis[v]=min(dis[v],dis[u]+d);
        }
    }
}

struct E{
    int v,w;
};
vector<E> G[N];
struct cmp{
    bool operator()(E a,E b){
        return a.w>b.w;
    }
};
priority_queue<E,vector<E>,cmp> pq;

vector<E> G[N];//存邊
priority_queue<E,vector<E>,cmp> pq;//dijkstra
ll dis[N];
void Dijsktra(){
	//init
	fill(dis,dis+n+1,INF);
	dis[1]=0;
	pq.push({1,0});//到1的距離為0（起點
	while(!pq.empty()){
		E cur=pq.top();pq.pop();
		if(dis[cur.v]<cur.w)continue;
		for(auto [v,w]:G[cur.v]){
			if(dis[v]>cur.w+w){
				pq.push({v,cur.w+w});
				dis[v]=cur.w+w;
			}
		}
	}
}

int deg[N];
vector<int> G[N],order;
queue<int> Q;
void topological_sort(){
    memset(deg,0,sizeof(deg));
    for(int i=0;i<n;++i){
        for(int j:G[i])++deg[j];
    }
    for(int i=0;i<n;++i){
        if(deg[i]==0)Q.push(i);
    }
    while(!Q.empty()){
        int cur=Q.front();//以下要拔掉cur，並更新連出去的點
        Q.pop();
        order.push_back(cur);
        for(int nxt:G[cur]){
            //cur轉移到nxt
            if(--deg[nxt]==0)Q.push(nxt);
        }
    }
}

int f[N];
void init(){
	for(int i=1;i<=n;++i)f[i]=i;
}
int fa(int me){
    if(f[me]==me)return me;
    return fa(f[me]);
}
void join(int a,int b){
    int A=fa(a),B=fa(b);
    f[A]=B;
}

int f[N],sz[N];
void init(){
	for(int i=1;i<=n;++i)f[i]=i,sz[i]=1;
}
int fa(int me){
    if(f[me]==me)return me;
    f[me]=fa(f[me]);//路徑壓縮
    return f[me];
}
void join(int a,int b){
    int A=fa(a),B=fa(b);
    if(sz[A]<sz[B]){
    	//A併到B
        f[A]=B;
        sz[A]+=sz[B];
    }else{
    	//B併到A
        f[B]=A;
        sz[B]+=sz[A];
    }
}

struct E{int u,v,w;};
bool cmp(E a,E b){return a.w<b.w;}
E edge[N];
int Kruskal(){
    sort(edge, edge+m, cmp);
    int ans=0;
    for(int i=0;i<m;i++){
        if(fa(edge[i].u)!=fa(edge[i].v)){
            ans+=edge[i].w;
            join(edge[i].u, edge[i].v);
        }
    }
    return ans;
}

struct E{int v,w;};
struct cmp{bool operator()(E a,E b){return a.w>b.w;}};
priority_queue<E,vector<E>,cmp> pq;
pq.push({1,0});
int ans=0;
dis[1]=0;//到樹距離
while(!pq.empty()){
	E cur=pq.top();pq.pop();
	if(vis[cur.v])continue;
	vis[cur.v]=1;
	ans+=cur.w;
	for(auto [v,w]:G[cur.v]){
		if(!vis[v]&&dis[v]>w){
			dis[v]=w;
			pq.push({v,w});
		}
	}
}