#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cctype>

#include<cstdlib>

#include<map>

#define maxn 200020

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

struct Splay{

    struct Node{

        int e[],fa;long long val,size;

    }tree[maxn];

    int root,tot;

    Splay(){    root=tot=;    }

    inline int iden(int x){    return x==tree[tree[x].fa].e[];    }

    inline void connect(int x,int fa,int how){    tree[x].fa=fa;    tree[fa].e[how]=x;    }

    inline void update(int x){    tree[x].size=tree[tree[x].e[]].size+tree[tree[x].e[]].size+;    }

    void rotate(int x){

        int y=tree[x].fa;    int r=tree[y].fa;

        int sony=iden(x);    int sonr=iden(y);

        if(root==y)    root=x;

        int b=tree[x].e[sony^];

        connect(b,y,sony);

        connect(y,x,sony^);

        connect(x,r,sonr);

        update(y);    update(x);

    }

    void splay(int pos,int to){

        to=tree[to].fa;

        while(tree[pos].fa!=to){

            if(tree[tree[pos].fa].fa==to)    rotate(pos);

            else

                if(iden(tree[pos].fa)==iden(pos)){    rotate(tree[pos].fa),rotate(pos);    }

                else    {rotate(pos),rotate(pos);    }

        }

    }

    inline int create(int fa,int val){

        tree[++tot]=(Node){{,},fa,val,};

        return tot;

    }

    inline int build(int val){

        if(root==){

            root=create(,val);

            return root;

        }

        int now=root;

        while(now){

            tree[now].size++;

            int nxt=val<tree[now].val?:;

            if(tree[now].e[nxt]==){

                connect(create(now,val),now,nxt);

                return tot;

            }

            now=tree[now].e[nxt];

        }

    }

    inline void insert(int val){

        int p=build(val);

        splay(p,root);

    }

    inline int find(int val){

        int now=root;

        while(now){

            if(tree[now].val==val)    return now;

            int nxt=val<tree[now].val?:;

            now=tree[now].e[nxt];

        }

        return ;

    }

    void dele(int x){

        tree[x].e[]=tree[x].e[]=;

        if(x==tot)    tot--;

    }

    void pop(int val){

        int now=find(val);

        if(now==)    return;

        splay(now,root);

        if(tree[now].e[]==){

            root=tree[now].e[];

            tree[root].fa=;

            dele(now);

            return;

        }

        int deal=tree[now].e[];

        while(tree[deal].e[])    deal=tree[deal].e[];

        splay(deal,tree[now].e[]);

        connect(tree[now].e[],deal,);

        root=deal;    tree[deal].fa=;

        update(deal);

        dele(now);

        return;

    }

    inline int lower(int val){

        int now=root,ans=-0x7fffffff;

        while(now){

            if(tree[now].val<val&&tree[now].val>ans)    ans=tree[now].val;

            int nxt=val<tree[now].val?:;

            now=tree[now].e[nxt];

        }

        return ans;

    }

    inline int upper(int val){

        int now=root,ans=0x7fffffff;

        while(now){

            if(tree[now].val>val&&tree[now].val<ans)    ans=tree[now].val;

            int nxt=val<tree[now].val?:;

            now=tree[now].e[nxt];

        }

        return ans;

    }

}s;

int d[maxn][];

long long    w[maxn][];

int dfn[maxn],ID;

int deep[maxn];

bool ext[maxn];

int back[maxn];

long long dis[maxn];

struct Edge{

    int next,to;

    long long val;

}edge[maxn*];

int head[maxn],num;

inline void add(int from,int to,long long val){

    edge[++num]=(Edge){head[from],to,val};

    head[from]=num;

}

void find(int x,int fa){

    dfn[x]=++ID;    back[ID]=x;

    deep[x]=deep[fa]+;

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==fa)    continue;

        dis[to]=dis[x]+edge[i].val;

        d[to][]=x;    w[to][]=edge[i].val;

        find(to,x);

    }

    return;

}

long long calcdis(int x,int y,int opt){

    long long ans=;

    if(deep[x]<deep[y])    swap(x,y);

    int f=deep[x]-deep[y];

    for(int i=;(<<i)<=f;++i)

        if(f&(<<i)){

            ans+=w[x][i];

            x=d[x][i];

        }

    if(x==y)    return opt==?ans:x;

    for(int i=;i>=;--i){

        if(d[x][i]==d[y][i])    continue;

        ans+=w[x][i]+w[y][i];

        x=d[x][i];    y=d[y][i];

    }

    return opt==?ans+w[x][]+w[y][]:d[x][];

}

int main(){

    int n=read(),m=read();

    for(int i=;i<n;++i){

        int from=read(),to=read(),val=read();

        add(from,to,val);

        add(to,from,val);

    }

    find(,);

    for(int j=;j<=;++j)

        for(int i=;i<=n;++i){

            d[i][j]=d[d[i][j-]][j-];

            w[i][j]=w[i][j-]+w[d[i][j-]][j-];

        }

    long long ans=;

    while(m--){

        int e=read();

        int dfe=dfn[e];

        if(ext[e]==){

            ext[e]=;

            int low=s.lower(dfe),upp=s.upper(dfe);

            if(low>)                    ans+=calcdis(back[low],e,);

            if(upp<=n)                    ans+=calcdis(back[upp],e,);

            if(low>&&upp<=n)            ans-=calcdis(back[low],back[upp],);

            s.insert(dfe);

        }

        else{

            ext[e]=;

            s.pop(dfe);

            int low=s.lower(dfe),upp=s.upper(dfe);

            if(low>)                    ans-=calcdis(back[low],e,);

            if(upp<=n)                    ans-=calcdis(back[upp],e,);

            if(low>&&upp<=n)            ans+=calcdis(back[low],back[upp],);

        }

        int last=s.lower(n+),first=s.upper();

        long long ret=;

        if(last>&&first<=n){

            int lca=calcdis(back[last],back[first],);

            ret=dis[back[last]]+dis[back[first]]-*dis[lca];

        }

        printf("%lld\n",ans+ret);

    }

    return ;

}