除了第一个点和最后几个点是 AC，其它都是 WA.

已经查了好长时间了，不知道是哪还有问题（

#include <iostream>
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cstring>

#define Heriko return
#define Deltana 0
#define Romanno 1
#define S signed
#define LL long long
#define DB double
#define R register
#define I inline
#define CI const int
#define CL const long long
#define mkp(a,b) make_pair(a,b)
#define mst(a,b) memset(a,b,sizeof(a))
#define ON std::ios::sync_with_stdio(false);cin.tie(0)
#define Files() freopen("RNMTQ.in","r",stdin);freopen("RNMTQ.out","w",stdout)

using namespace std;

template<typename J>
I void fr(J &x) {
    short f(1);
    x=0;
    char c(getchar());

    while(c<'0' or c>'9') {
        if(c=='-')
            f=-1;
        
        c=getchar();
    }

    while(c>='0' and c<='9') {
        x=(x<<3)+(x<<1)+(c^=48);
        c=getchar();
    }
   
    x*=f;
}

template<typename J>
I void fw(J x,bool k) {
    if(x<0)
        x=-x,putchar('-');

    static short stak[35];
    short top(0);

    do {
        stak[top++]=x%10;
        x/=10;
    }
    while(x);

    while(top)
        putchar(stak[--top]+'0');

    k?puts(""):putchar(' ');
}

template<typename J>
I J Hmax(const J &x,const J &y) {
    Heriko x>y?x:y;
}

template<typename J>
I J Hmin(const J &x,const J &y) {
    Heriko x<y?x:y;
}

CI MXX(2e5+1);
CL INF(123456789123456789);

struct Edge {
    int nex,to;
    LL v;
}

r[MXX<<1];

int rcnt,head[MXX];

I void Add(int x,int y,LL z) {
    r[++rcnt]=(Edge){head[x],y,z},head[x]=rcnt;
    r[++rcnt]=(Edge){head[y],x,z},head[y]=rcnt;
}

int dep[MXX],son[MXX],top[MXX],fa[MXX],id[MXX],antid[MXX],idcnt,sz[MXX];
LL dis[MXX];

void DFS1(int x,int fath) {
    fa[x]=fath,sz[x]=1,dep[x]=dep[fath]+1;

    for(int i(head[x]);i;i=r[i].nex) {
        int y(r[i].to);

        if(y==fath)
            continue;

        dis[y]=dis[x]+r[i].v;
        DFS1(y,x);
        sz[x]+=sz[y];

        if(sz[y]>sz[son[x]])
            son[x]=y;
    }
}

void DFS2(int x,int tp) {
    top[x]=tp,id[x]=++idcnt,antid[idcnt]=x;

    if(son[x])
        DFS2(son[x],tp);

    for(int i(head[x]);i;i=r[i].nex) {
        int y(r[i].to);

        if(y==fa[x] or y==son[x])
            continue;
        
        DFS2(y,y);
    }
}

I int LCA(int x,int y) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);

        x=fa[top[x]];
    }
    
    Heriko dep[x]<dep[y]?x:y;
}

struct Line {
    int k;
    LL b;

    Line(CI &x=0,CL &y=INF) : k(x),b(y){}

    I LL Clac(LL x) {
        Heriko k*x+b;
    }
};

#define lc(x) (x<<1)
#define rc(x) (x<<1|1)

struct Node {
    Line f;
    int l,r;
    LL val;
}

t[MXX<<2];

I void Pushup(int x) {
    t[x].val=Hmin(t[x].val,Hmin(t[x].f.Clac(dis[antid[t[x].l]]),t[x].f.Clac(dis[antid[t[x].r]])));
    t[x].val=Hmin(t[x].val,Hmin(t[lc(x)].val,t[rc(x)].val));
}

void Build(int x,int l,int r) {
    t[x].l=l,t[x].r=r,t[x].val=INF;

    if(l==r)
        Heriko;

    int mid((l+r)>>1);
    Build(lc(x),l,mid);
    Build(rc(x),mid+1,r);
}

void Modify(int x,int lx,int rx,Line v) {
    int mid((t[x].l+t[x].r)>>1);

    if(lx<=t[x].l and t[x].r<=rx) {
        if(v.Clac(dis[antid[mid]])<t[x].f.Clac(dis[antid[mid]]))
            swap(t[x].f,v);

        if(v.Clac(dis[antid[t[x].l]])<t[x].f.Clac(dis[antid[t[x].l]]))
            Modify(lc(x),lx,rx,v);

        if(v.Clac(dis[antid[t[x].r]])<t[x].f.Clac(dis[antid[t[x].r]]))
            Modify(rc(x),lx,rx,v);

        Pushup(x);

        Heriko;
    }

    if(lx<=mid)
        Modify(lc(x),lx,rx,v);

    if(rx>mid)
        Modify(rc(x),lx,rx,v);

    Pushup(x);
}

LL Query(int x,int lx,int rx) {
    if(lx<=t[x].l and t[x].r<=rx)
        Heriko t[x].val;

    int mid((t[x].l+t[x].r)>>1);
    LL res(Hmin(t[x].f.Clac(dis[antid[Hmax(lx,t[x].l)]]),t[x].f.Clac(dis[antid[Hmin(rx,t[x].r)]])));

    if(lx<=mid)
        res=Hmin(res,Query(lc(x),lx,rx));

    if(rx>mid)
        res=Hmin(res,Query(rc(x),lx,rx));

    Heriko res;
}

I void MTree(int x,int y,Line v) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);

        Modify(1,id[top[x]],id[x],v);
        x=fa[top[x]];
    }

    if(dep[x]>dep[y])
        swap(x,y);

    Modify(1,id[x],id[y],v);
}

I LL QTree(int x,int y) {
    LL res(INF);

    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);

        res=Hmin(res,Query(1,id[top[x]],id[x]));
        x=fa[top[x]];
    }

    if(dep[x]>dep[y])
        swap(x,y);

    res=Hmin(res,Query(1,id[x],id[y]));

    Heriko res;
}

int n,m;

S main() {
    Files();

    fr(n),fr(m);

    for(int i(1);i<n;++i) {
        int x,y;
        LL z;
        fr(x),fr(y),fr(z);
        Add(x,y,z);
    }

    Build(1,1,n);
    DFS1(1,0);
    DFS2(1,1);

    while(m--) {
        int opt,s,t;
        fr(opt),fr(s),fr(t);

        if(opt==1) {
            int x,y,lca;
            fr(x),fr(y),lca=LCA(s,t);// fw(s,0),fw(t,0),fw(x,0),fw(y,0),fw(lca,1);
            MTree(s,lca,Line(-x,x*dis[s]+y));            
            MTree(lca,t,Line(x,x*(dis[s]-2*dis[lca])+y));
        }
        else
            fw(QTree(s,t),1);
    }

    Heriko Deltana;
}