CSUSTOJ 神秘群岛（图论）

题目1001

题意：
大概意思就是N个节点N-1条双向边(暗示) ， u v返回方向不同时的贡献也不同，求从x出发到y最多能收集到多少贡献最多。

解法：
传送门只能用一次，而且是树结构，显然对于v我们必须有一条延申出去的路径获取不到贡献，同理u进来的路径获取不到贡献因为他不会再回到u或者离开v，否则无法到达。那么问题等价于权值和，减去不能取的最短路径花费，那么获得的贡献就最大，从1为根做LCA预处理，倍增O1查询，对于建边每次建立在父节点与儿子节点的两种图上，记录根到每个节点的最短距离。

const int manx=5e5+500;
const int mamx=1e6+5;
ll head[manx],head_[manx];
ll vis[manx];
ll n,m,k=0,s,kk=0;
long long d[manx],d_[manx];
const int maxn=510000;
ll head_lca[maxn],depth[maxn],fa[maxn][50],num=0;
ll degree[maxn];
struct nodes
{
    int next,to;
};
struct nodes edge[maxn];
void add_lca(ll u,ll v)
{
    edge[num].next=head_lca[u];
    edge[num].to=v;
    head_lca[u]=num++;
}

void dfs(ll u, ll pre, ll d)
{
    // printf ("%d %d\n",u,d);
    fa[u][0] = pre, depth[u] = d;
    for(ll i = head_lca[u]; i != -1; i = edge[i].next)
    {
        ll to = edge[i].to;
        if(to != pre)
            dfs(to, u, d + 1);
    }
}
void init(ll root)
{
    dfs(root, -1, 0);
    for(ll j = 0; (1 << (j + 1)) < n; j++)
    {
        for(ll i = 1; i <= n; i++)
        {
            if(fa[i][j] < 0)
                fa[i][j + 1] = -1;
            else
                fa[i][j + 1] = fa[fa[i][j]][j];
            //  printf ("%d %d %d\n",i,j,fa[i][j]);
        }
    }
}
int LCA(ll u, ll v)
{
    if(depth[u] > depth[v])
        swap(u, v);
    int temp = depth[v] - depth[u];
    for(ll i = 0; (1 << i) <= temp; i++)
    {
        if((1 << i) & temp)
            v = fa[v][i];
    }
    if(v == u)
        return u;
    for(ll i = log(n*1.0)/log(2.0); i >= 0; i--)
    {
        if(fa[u][i] != fa[v][i])
        {
            u = fa[u][i], v = fa[v][i];
        }
    }
    return fa[u][0];
}

/*
//ll rnm[444444];
int main(){
//init(1);
memset(head,-1,sizeof(head));

//n=read();
scanf("%d",&n);
//ll k1=read();
//ll ans=1;
ll k;
for(ll i=1;i<=n-1;i++){
  //ll x=read();
  //ll y=read();
  ll x,y;
  scanf("%d%d",&x,&y);
  add(x,y);
  add(y,x);

}init(1);
ll q;
scanf("%d",&q);
while(q--){

    ll x,y;
  scanf("%d%d",&x,&y);
  printf("%d\n",LCA(x,y));
}
}

*/
struct node
{
    ll v,next,w;
} a[mamx];
void add(ll u,ll v,ll w)
{
    a[++k].next=head[u];
    a[k].w=w;
    a[k].v=v;
    head[u]=k;
}

struct nodee
{
    ll v,next,w;
} a_[mamx];
void add_(ll u,ll v,ll w)
{
    a_[++kk].next=head_[u];
    a_[kk].w=w;
    a_[kk].v=v;
    head_[u]=kk;
}


void dij()
{
    memset(d,inf,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0;
    priority_queue<pair<ll,ll> >q;
    q.push(mp(0,s));
    while(q.size())
    {
        ll u=q.top().se;
        q.pop();
        if(vis[u])
            continue;
        vis[u]=1;
        for(int i=head[u]; i; i=a[i].next)
        {
            ll v=a[i].v,w=a[i].w;
            if(d[v]>d[u]+w)
            {
                //printf("qwq %lld\n",d[v]);      //松弛操作，更新距离
                d[v]=d[u]+w;
                // printf("sad %lld %lld %lld %lld\n",d[u],u,res,d[v]);
                q.push(mp(-d[v],v)); //把更新的距离和点入队，这里距离取负变成小根堆
            }

        }
    }
}

void dij_()
{
    memset(d_,inf,sizeof(d_));
    memset(vis,0,sizeof(vis));
    d_[s]=0;
    priority_queue<pair<ll,ll> >q;
    q.push(mp(0,s));
    while(q.size())
    {
        ll u=q.top().se;
        q.pop();
        if(vis[u])
            continue;
        vis[u]=1;
        for(int i=head_[u]; i; i=a_[i].next)
        {
            ll v=a_[i].v,w=a_[i].w;
            if(d_[v]>d_[u]+w)
            {
                //printf("qwq %lld\n",d[v]);      //松弛操作，更新距离
                d_[v]=d_[u]+w;
                // printf("sad %lld %lld %lld %lld\n",d[u],u,res,d[v]);
                q.push(mp(-d_[v],v)); //把更新的距离和点入队，这里距离取负变成小根堆
            }

        }
    }
}

struct rnmb
{
    ll u,v,w,q;

} fuck[222222];
signed main()
{
    ll t;
    read(t);
    while(t--)
    {
        memset(head_lca,-1,sizeof(head_lca));
        memset(fa,0,sizeof(fa));
        memset(depth,0,sizeof(depth));
        memset(head,0,sizeof(head));
        memset(head_,0,sizeof(head_));
        k=0;
        kk=0;
        num=0;
        read(n);
        long long sum=0;
        for(int i=1; i<n; i++)
        {
            ll u,v,w,q;
            read(fuck[i].u);
            read(fuck[i].v);
            read(fuck[i].w);
            read(fuck[i].q);
            add_lca(fuck[i].u,fuck[i].v);
            add_lca(fuck[i].v,fuck[i].u);
            sum=sum+fuck[i].w+fuck[i].q;
        }
        init(1);
        for(int i=1; i<n; i++)
        {
            if(fa[fuck[i].v][0]==fuck[i].u)
            {
                add_(fuck[i].u,fuck[i].v,fuck[i].q);
                add(fuck[i].u,fuck[i].v,fuck[i].w);
            }
            else
            {
                add(fuck[i].v,fuck[i].u,fuck[i].q);
                add_(fuck[i].v,fuck[i].u,fuck[i].w);
            }

        }
        s=1;
        dij();
        dij_();
        ll qq;
        read(qq);
        while(qq--)
        {
            ll xx,yy;
            read(xx);
            read(yy);
            ll rnm=LCA(xx,yy);
            long long dis=sum-(d[xx]-d[rnm]+d_[yy]-d_[rnm]);
            printf("%lld\n",dis);

        }

    }
}