#include<bits/stdc++.h>
using namespace std;
const int size=3000010;
int tot,head[size];
int n,m;
int l,r;
int ans;
struct node
{
	int next;
	int to;
	int wea;
}edge[size*2];
struct eg
{
	int start;
	int end;
	int dis;//?
	int lca;
}edd[size*2];

void edge_add(int u,int v,int w)
{
	edge[++tot].to=v;
	edge[tot].next=head[u];
	edge[tot].wea=w;
	head[u]=tot;
}
bool cmp(eg t,eg p)
{
	return t.dis>p.dis;
} 

int lg[size];
int father[size][25];
int deep[size];
int val[size];//chafneshuzu
int len[size];
int wea[size];


//该维护的维护 
void dfs1(int now,int fa,int depth)
{
	deep[now]=depth;
	father[now][0]=fa;
	for(int i=1;i<=20;i++)
	{
		father[now][i]=father[father[now][i-1]][i-1];
	}
	for(int i=head[now];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(v!=fa)
		{
			len[v]=len[now]+edge[i].wea;
			wea[v]=edge[i].wea;
			dfs1(v,now,depth+1);
		} 
	}
	
}
//板子
int LCA(int a,int b)
{
	
	if(deep[a]<deep[b])
	{
		swap(a,b);
	}
	while(deep[a]!=deep[b])
	{
		
		a=father[a][lg[deep[a]-deep[b]-1]];
		
	}
	
	if(a==b) return a;
	for(int i=lg[deep[a]]-1;i>=0;i--)
	{
		if(father[a][i]!=father[b][i])
		{
			a=father[a][i];
			b=father[b][i];
		}
	}
	return father[a][0];
}

//这个dfs估计是求差分数组的和 
//纯板子 
void dfs2(int u,int fath)
{
	for(int i=head[u];i;i=edge[i].next)
	{
		int e=edge[i].to;
		if(e==fath) continue;
		dfs2(e,u);
		val[u]+=val[e];
	}
}

bool check(int lim)
{
	int cnt;
	int maxn=0;
	memset(val,0,sizeof(val));
	for(int i=1;i<=m;i++)
	{
		if(edd[i].dis<=lim) break;
		val[edd[i].start]++;
		val[edd[i].end]++;
		val[edd[i].lca]-=2;
		cnt++;
	}//差分数组
	dfs2(1,0);
	for(int i=1;i<=n;i++)
	{
		if(val[i]==cnt)
		{
			maxn=max(maxn,wea[i]);
		}
	}
	return edd[1].dis-maxn<=lim;
}
inline int read()
{
	int x=0;
	int f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}
int main()
{
	n=read();
	m=read();
	int u,v,w;
	for(int i=1;i<n;i++)
	{
		u=read();
		v=read();
		w=read();
		edge_add(u,v,w);
		edge_add(v,u,w);
		l=max(l,w);
    }
	for(int i=1;i<=size;i++)
	{
		lg[i]=lg[i-1]+(1<<(lg[i-1]==i));
	}
	dfs1(1,0,1);
	for(int i=1;i<=m;i++)
	{
		u=read();
		v=read();
		edd[i].start=u;
		edd[i].end=v;
		edd[i].lca=LCA(edd[i].start,edd[i].end);
		edd[i].dis=len[edd[i].start]+len[edd[i].end]-(len[edd[i].lca]<<1);
		r=max(r,edd[i].dis);
		
	}
	sort(edd+1,edd+m+1,cmp);
	l=r-l;
	while(l<=r)
	{
		int mid=(l+r)>>1;
		if(check(mid))
		{
			ans=mid;
			r=mid-1;
		}
		else l=mid+1;
	}
	cout<<ans<<endl;
	return 0;
}