#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int gen[5005],n,m,ans,cnt;

struct Edge{
    int u;//左边的点
    int v;//右边的点
    int w;//权值
}edge[200005];

bool cmp(Edge a,Edge b){//排序方法
    return a.w<b.w;
}
int find(int x){
    if(gen[x]==x) return x;
    return gen[x]=find(gen[x]);
}

inline void kruskal(){
    sort(edge+1,edge+m+1,cmp);//按照权值排序
    for(int i=1;i<=m;i++){
        int eu=find(edge[i].u);//找到左边点和右边点的老大
        int ev=find(edge[i].v);
        if(ev==eu){//如果老大是一个，说明这俩在一个集合中，跳过
            continue;
        }//否则
        ans+=edge[i].w;//加上权值
        gen[ev]=eu;//连接两个并查集
        cnt++;
        if(cnt==n-1){//退出的条件
            break;
        }
    }
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        gen[i]=i;
    }
    for(int i=1;i<=m;i++){
        cin>>edge[i].u>>edge[i].v>>edge[i].w;
    }
    kruskal();
    cout<<ans;
    return 0;
}

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn=200001;
bool selected[maxn];//是否被选中，初始为0
int minDist[maxn];//最小值，初始为INF
int parent[maxn];//存储最小值的那个边的父亲，初始为-1，代表不存在
int n,m,cnt,ans;

struct Edge{
	int begin;
	int end;
	int longth;
}edge[maxn];

void Prim(int x){
	cnt++;
	for(int i=1;i<=m;i++){
		if(edge[i].begin==x&&minDist[edge[i].end]>edge[i].longth){
			minDist[edge[i].end]=edge[i].longth;
			parent[edge[i].end]=x;	
		}else if(edge[i].end==x&&minDist[edge[i].begin]>edge[i].longth){
			minDist[edge[i].begin]=edge[i].longth;
			parent[edge[i].begin]=x;
		}
	}
}
int main(){
	ios::sync_with_stdio(false);
    cin.tie(0);
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>edge[i].begin>>edge[i].end>>edge[i].longth;
	}
	memset(minDist,0x3f3f3f,sizeof(minDist));//minDist初始化
	selected[1]=1;//先选择1加入最小生成树中
	Prim(1);//遍历查找
	while(cnt!=n){//循环
		int minn=0x3f3f3f;
		int chose=1;
		for(int i=1;i<=n;i++){
			if(!selected[i]&&minDist[i]<minn){
				minn=minDist[i];
				chose=i;
			}
		}
		selected[chose]=1;
		ans+=minn;
		Prim(chose);
	}
	cout<<ans;
	return 0;
}

for(int i=1;i<=n;i++){
    f[i]=i;	//初始化
}

int find(int k){
    if(f[k]==k) return k;	//如果自己是自己所在集合的帮主，那它就是总帮主
    return find(f[k]);		//如果不是，就找他老大哥的老大哥
}

int find(int k){
   if(f[k]==k) return k;	//如果自己是自己所在集合的帮主，那它就是总帮主
    return f[k]=find(f[k]);		//把图中的人的老大哥都变成总帮主
}

if(find(p1)==find(p2)){	//如果这俩隶属于同一个帮派
    cout<<"YES"<<endl;
}else{
    cout<<"NO"<<endl;
}

f[find(a)]=find(b);		//让b和a的帮主变成一个人

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=10005;
int n,m,f[maxn];

int find(int k){
    if(f[k]==k) return k;//如果自己的老大就是自己，那它就是总老大
    return f[k]=find(f[k]);//使途中经过的人的大哥也变成老大
}

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        f[i]=i;//初始化i的老大为自己
    }
    for(int i=1,p1,p2,p3;i<=m;i++){
        cin>>p1>>p2>>p3;
        if(p1==1){//如果是执行合并操作
            f[find(p2)]=find(p3);//让p2的老大变成p3的老大
        }else{//查询操作
            if(find(p2)==find(p3)){//如果p2的老大和p3的老大是一个人
                cout<<"Y"<<endl;
            }else{
                cout<<"N"<<endl;
            }
        }
    }

    return 0;
}

#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
const int maxn=1000;
vector<int>vec[maxn]; // 邻接表建图。
int du[maxn];
int n,m;
void topsort(){
	priority_queue<int,vector<int>,greater<int> > s;//使用优先队列，来保证输出时编号小的队伍在前
	int flag=0;
	for(int i=1;i<=n;i++)
	{
		if(!du[i])//将入度为0的节点入队
			s.push(i);
	}
	while(!s.empty())
	{
		int now=s.top();
       	  s.pop();
		if(flag==0)
		{
			cout<<now;
			flag=1;
		}
		else
			cout<<" "<<now; // 最后一名没有空格
		
		for(int i=0;i<vec[now].size();i++) //除去与该节点相关的节点的关联边。
		{
			if(--du[vec[now][i]]==0)	
				s.push(vec[now][i]);
		}
	}
}
int main(){

	while(cin>>n>>m)
	{
		memset(du,0,sizeof(du));
		for(int i=1;i<=n;i++)
			vec[i].clear();
		for(int i=1;i<=m;i++)
		{
			int a,b;
			cin>>a>>b;
			vec[a].push_back(b);
			du[b]++;
		}
		topsort();
		cout<<endl;
	}
	return 0;	
} 

void floyd()
{
    for(int k = 0; k < n; k ++){ //作为循环中间点的k必须放在最外一层循环 
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                if(dist[i][j] > dist[i][k] + dist[k][j]){
                    dist[i][j] = dist[i][k] + dist[k][j];    //dist[i][j]得出的是i到j的最短路径 
                }     
            }    
        }    
    }    
}

void tarjan(int u){
	instack[u] = true;//u是否在栈中
	stack[top] = u;//入栈
	low[u] = dfn[u] = ++cnt;//初始化
	for(int i=0;i<vec[u].size();i++){
		int v = vec[u][i];//下一个节点
		if(!dfn(v)){
			tarjan(v);
			//回溯时更新
			low[u] = min(low[u],low[v]);
		}else if(instack(v)){//这个点还在栈中（这尤为重要，若要一个点个指向一个强连通分量，没有这句话，那么low将会变小）
			/*访问到根节点，或者其他情况.这里需要注意一下。强连通图中可以用low[u] = min(low[u],low[v]);但是在割点这种问题就必须要下面这种格式。推荐使用这种*/
			low[u] = min(low[u],dfn[v]);
		}
	}
	int j;
	if(low[u] == dfn[u]){//判断
		ans++;
		do{
			j=stack[top--];
			instack[j] = false;
			Belong[j] = ans;//染色，也就是哪一些是连通块。
		}while(j!=u)
	}
}

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int index;//序数
int ans;//答案
int top;//栈顶
int n,m;
bool instack[100010];//记录这个节点是否在栈中
int stack[100010];
int dfn[100010];
int low[100010];
vector<int> M[100010];//图
void tarjan(int u){
	int v;
	low[u] = dfn[u] = ++index;
	stack[++top] = u;
	instack[u] = true;
	for(int i=0;i<M[u].size();i++){
		v = M[u][i];
		if(!dfn[v]){
			tarjan(v);
			low[u] = min(low[u],low[v]);
		}else if(instack[v]){
			low[u] = min(low[u],dfn[v]);
		} 
	}
	if(dfn[u] == low[u]){
		int x=0;
		do{
			v = stack[top--];//出栈
			x++;
			instack[v] = false;//出栈
		}while(u!=v);
		if(x>1) ans++;//如果这个强连通分量里面的节点数大于1
	}
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int x,y;
		cin>>x>>y;
		M[x].push_back(y);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i]){//若没有被访问过 
			tarjan(i);
		}
	}
	cout<<ans;
	return 0;
}

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int ans;//答案
int top;//栈顶
int n,m;
int x;//记录该强连通节点的个数 
bool v1[100010];//第一遍历的标记 
bool v2[100010]; //第二次遍历的标记 
int stack[100010];//栈 
vector<int> M1[100010];//图
vector<int> M2[100010];//反图
void dfs1(int u){
	for(int i=0;i<M1[u].size();i++){
		int next = M1[u][i];
		if(!v1[next]){
			v1[next] = true;
			dfs1(next);
		}
	}
	stack[++top] = u;//后序入栈 
}
void dfs2(int u){//对反图进行dfs 
	x++;//记录 
	for(int i=0;i<M2[u].size();i++){
		int next = M2[u][i];
		if(!v2[next]){
			v2[next] = true;
			dfs2(next);
		}
	}
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int x,y;
		cin>>x>>y;
		M1[x].push_back(y);
		M2[y].push_back(x);//返图 
	}
	for(int i=1;i<=n;i++){
		if(!v1[i]){//若没有被访问过 
			v1[1] = true;
			dfs1(i);
		}
	}
	while(top){
		int v = stack[top--];//出栈
		x = 0;
		if(!v2[v]){
			v2[v] = true;
			dfs2(v);
		} 
		if(x > 1) ans++;
	} 
	cout<<ans;
	return 0;
}

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int ans;//答案
int t1;//栈顶
int t2;//栈顶 
int n,m;
int index;
int x;//记录该强连通节点的个数 
int dfn[100010];
int stack_2[100010]; 
int stack_1[100010];//栈 
int instack[100010];
vector<int> M[100010];//图
void Gabow(int u){
	dfn[u] = ++index;
	stack_1[++t1] = stack_2[++t2] = u;
	instack[u] = 1;
	for(int i=0;i<M[u].size();i++){
		int v = M[u][i];
		if(!dfn[v]){
			Gabow(v);
			//while(dfn[stack_2[t2]]>dfn[v]) t2--; 这里加不加好像都可以
		}else if(instack[v]){
			while(dfn[stack_2[t2]]>dfn[v]) t2--;
		}
	}
	if(u==stack_2[t2]){
		int j;
		do{
			j = stack_1[t1--];
			x++;
			instack[j] = 0;
		}while(u!=j);
	}
	if(x>1) ans++;
} 

int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int x,y;
		cin>>x>>y;
		M[x].push_back(y);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i]){//若没有被访问过 
			x = 0;
			Gabow(i);
		}
	}
	cout<<ans;
	return 0;
}