CodeChef VLB Vasya and Little Bear (树上莫队)

本文深入探讨了树上莫队算法的实现细节,通过具体题目解析,展示了如何利用树上莫队算法解决路径上颜色价值计算的问题。文章详细解释了树上分块、双端队列维护、路径顺序影响等关键概念,并提供了完整的代码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题意:

       一棵树,每个点有一种颜色(10以内),一个价值,现在有Q次询问,每次询问在path(u,v)上,对于每种颜色算价值,价值是路径上相同颜色相邻的点的价值差的平方,如:u到v上颜色为1的点价值分别为a,b,c,则产生的价值是(ab)2+(bc)2(a−b)2+(b−c)2,注意,LCA(u,v)的颜色的价值不要

思路:

       树上莫队,那么首先对树分块,然后存询问,然后思考下怎么转移
       首先,L->L’和R-R’肯定是要分开维护的,所以使用双端队列维护,一个用front,一个用back,其次,路径顺序是对答案有影响的,那么比如我们在转移u->v的时候,要u->lca(u,v)->v,那么我们要先把路径保存下来,再进行处理

错误及反思:

代码:

#include<bits/stdc++.h>
using namespace std;
const int N = 100100;

stack<int> s; //分块时需要
int blocks,nowblo;//块大小,当前处于哪个块
int n,m;//节点数,问题数
int to[N][20],depth[N];//LCA
int block[N];
long long now,ans[N];
int head[N],tot;//链式前向星
bool vis[N];//标记路径

long long num[15];
int col[N],val[N];
deque<int> c[15];


struct EDGE{
    int to,nex;
}e[N*2];//双向边

void add(int x,int y){
    e[tot].nex=head[x];
    e[tot].to=y;
    head[x]=tot++;
}

struct Q{
    int l,r,id;
}q[N];

bool cmp(Q a,Q b){ //排序
    if(block[a.l]!=block[b.l])
        return block[a.l]<block[b.l];
    return block[a.r]<block[b.r];
}

void dfsblock(int now,int fa,int dep){ //树上分块
    int si=s.size();
    to[now][0]=fa;  depth[now]=dep;
    for(int i=head[now];i!=-1;i=e[i].nex){
        int x=e[i].to;
        if(x!=fa){
            dfsblock(x,now,dep+1);
            if(s.size()-si>=blocks){
                while(s.size()!=si){
                    block[s.top()]=nowblo;
                    s.pop();
                }
                nowblo++;
            }
        }
    }
    s.push(now);
}

void getlca(){   //预处理lca
    for(int i=1;i<=18;i++)
        for(int j=1;j<=n;j++)
            to[j][i]=to[to[j][i-1]][i-1];
}

int lca(int a,int b){ //得到lca
    if(depth[a]>depth[b]) swap(a,b);
    for(int i=18;i>=0;i--) //注意大小
        if(depth[to[b][i]]>=depth[a])
            b=to[b][i];
    if(a==b) return a;
    for(int i=18;i>=0;i--){ //注意大小
        if(to[a][i]!=to[b][i]){
            a=to[a][i];
            b=to[b][i];
        }
    }
    return to[a][0];
}

void change(int u,int v,int x){ //修改的时候将路径取反且不要动lca
    int ancs=lca(u,v);
    while(u!=ancs){
        if(!vis[u]){
            if(x){
                if(c[col[u]].size()>0){
                    now+=1ll*(val[c[col[u]].front()]-val[u])*(val[c[col[u]].front()]-val[u]);
                    num[col[u]]+=1ll*(val[c[col[u]].front()]-val[u])*(val[c[col[u]].front()]-val[u]);
                }
                c[col[u]].push_front(u);
            }
            else{
                if(c[col[u]].size()>0){
                    now+=1ll*(val[c[col[u]].back()]-val[u])*(val[c[col[u]].back()]-val[u]);
                    num[col[u]]+=1ll*(val[c[col[u]].back()]-val[u])*(val[c[col[u]].back()]-val[u]);
                }
                c[col[u]].push_back(u);
            }
        }
        else{
            if(x){
                if(c[col[u]].size()>=2){
                    int w=val[c[col[u]].front()];
                    c[col[u]].pop_front();
                    num[col[u]]-=1ll*(val[c[col[u]].front()]-w)*(val[c[col[u]].front()]-w);
                    now-=1ll*(val[c[col[u]].front()]-w)*(val[c[col[u]].front()]-w);
                }
                else
                    c[col[u]].pop_front();
            }
            else{
                if(c[col[u]].size()>=2){
                    int w=val[c[col[u]].back()];
                    c[col[u]].pop_back();
                    num[col[u]]-=1ll*(val[c[col[u]].back()]-w)*(val[c[col[u]].back()]-w);
                    now-=1ll*(val[c[col[u]].back()]-w)*(val[c[col[u]].back()]-w);
                }
                else
                    c[col[u]].pop_back();
            }
        }
        vis[u]=!vis[u];
        u=to[u][0];
    }
    vector<int> tmp;
    while(v!=ancs){
        tmp.push_back(v);
        v=to[v][0];
    }

    for(int i=tmp.size()-1;i>=0;i--){
        int k=tmp[i];
       // printf("%d %d\n",ancs,k);
        if(!vis[k]){
            if(x){
                if(c[col[k]].size()>0){
                    now+=1ll*(val[c[col[k]].front()]-val[k])*(val[c[col[k]].front()]-val[k]);
                    num[col[k]]+=1ll*(val[c[col[k]].front()]-val[k])*(val[c[col[k]].front()]-val[k]);
                }
                c[col[k]].push_front(k);
            }
            else{
                if(c[col[k]].size()>0){
                    now+=1ll*(val[c[col[k]].back()]-val[k])*(val[c[col[k]].back()]-val[k]);
                    num[col[k]]+=1ll*(val[c[col[k]].back()]-val[k])*(val[c[col[k]].back()]-val[k]);
                }
                c[col[k]].push_back(k);
            }
        }
        else{
            if(x){
                if(c[col[k]].size()>=2){
                    int w=val[c[col[k]].front()];
                    c[col[k]].pop_front();
                    num[col[k]]-=1ll*(val[c[col[k]].front()]-w)*(val[c[col[k]].front()]-w);
                    now-=1ll*(val[c[col[k]].front()]-w)*(val[c[col[k]].front()]-w);
                }
                else
                    c[col[k]].pop_front();
            }
            else{
                if(c[col[k]].size()>=2){
                    int w=val[c[col[k]].back()];
                    c[col[k]].pop_back();
                    num[col[k]]-=1ll*(val[c[col[k]].back()]-w)*(val[c[col[k]].back()]-w);
                    now-=1ll*(val[c[col[k]].back()]-w)*(val[c[col[k]].back()]-w);
                }
                else
                    c[col[k]].pop_back();
            }
        }
        vis[k]=!vis[k];
    }
}

void init(){
    memset(head,-1,sizeof(head));
    memset(vis,false,sizeof(vis));
    blocks=sqrt(n);
    nowblo=0;
    now=0; tot=0;
}

int main(){
    scanf("%d",&n);
    init(); //初始化
    for(int i=1;i<=n;i++) scanf("%d",&col[i]);
    for(int i=1;i<=n;i++) scanf("%d",&val[i]);

    for(int i=1,u,v;i<n;i++){   //树的边
        scanf("%d%d",&u,&v);
        add(v,u); add(u,v);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++){      //问题
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }
    dfsblock(1,1,1);    //树上分块
    while(s.empty()){
        block[s.top()]=nowblo-1;
        s.pop();
    }
    getlca(); //预处理倍增lca
    sort(q+1,q+m+1,cmp); //问题排序
    for(int i=1,l=1,r=1;i<=m;i++){
        if(l!=q[i].l) change(l,q[i].l,0);  //左边节点

        if(r!=q[i].r) change(r,q[i].r,1); //右边节点
        int ancs=lca(q[i].l,q[i].r);
        ans[q[i].id]=now-num[col[ancs]];
        l=q[i].l; r=q[i].r;

       // printf("%lld %lld\n",num[col[ancs]],now);
    }
    for(int i=1;i<=m;i++)
        printf("%lld\n",ans[i]);
}
MATLAB 中并没有直接提供名为 `vlb` 的内置功能或库。然而,根据问题描述以及提供的参考资料[^1][^2][^3][^4],可以推测您可能是在寻找与优化、线性规划或其他数值计算相关的内容。 以下是关于 MATLAB 中类似的优化功能及其使用方法的详细介绍: ### 1. MATLAB中的优化工具箱 MATLAB 提供了一个强大的 **Optimization Toolbox** 工具箱,其中包含了多种用于解决不同类型的优化问题的功能和算法。这些功能涵盖了线性规划 (Linear Programming, LP)、整数线性规划 (Integer Linear Programming, ILP) 和非线性规划 (Nonlinear Programming, NLP)[^2]。 #### 线性规划求解器 (`linprog`) 如果您正在处理的是标准形式的线性规划问题,则可以考虑使用 `linprog` 函数来解决问题。它的语法如下所示: ```matlab [x,fval] = linprog(f,A,b,Aeq,beq,lb,ub); ``` - 参数说明: - `f`: 目标函数系数向量; - `A`, `b`: 不等式约束矩阵及右侧常数向量; - `Aeq`, `beq`: 等式约束矩阵及右侧常数向量; - `lb`, `ub`: 变量上下界的向量; 对于更复杂的混合整数线性规划问题,可采用 `intlinprog` 函数完成相应操作[^1]。 --- ### 2. 自定义外部求解器集成(如 lpsolve) 当默认工具无法完全满足特定需求时,还可以引入第三方开源软件包扩展能力范围。例如,在某些情况下用户可能会倾向于利用专门设计好的 C/C++ 或 Python 实现并将其嵌入至 MATLAB 脚本环境中运行。具体做法包括但不限于调用系统命令行接口执行预编译二进制程序或将动态链接库加载进来作为自定义 MEX 文件的一部分加以运用[^1]。 要实现这一点,请遵循以下步骤: 1. 访问指定网站地址 http://sourceforge.net/projects/lpsolve/files/lpsolve/ 下载适合当前平台架构版本号对应的压缩包文件。 2. 解压后阅读文档指南了解安装配置流程详情。 3. 编写相应的封装层以便于无缝衔接现有工作流逻辑结构之中去。 --- ### 3. 关于物流选址问题的应用实例 结合所提供的背景资料来看,您的实际应用场景似乎涉及到了某种形式上的设施布局决策制定过程——即所谓的“物流中心位置选取”。这类课题往往需要综合考量诸如运输距离成本效益分析等多种因素相互作用关系才能得出最优方案建议[^3]^。 在此类情境之下,除了单纯依赖传统意义上的数学建模技术手段之外,我们还能够借助现代启发式搜索策略比如遗传算法(Genetic Algorithm),模拟退火(Simulated Annealing)等等进一步提升最终解答质量水平。与此同时,为了简化复杂网络拓扑结构内部各节点之间连通性的评估难度,Floyd-Warshall 方法因其简单易懂且效率较高而成为一种不错的选择对象之一[^4]。 下面给出一段简单的伪代码片段展示如何应用 Floyd-Warshall 来获取任意两点间的最短路径长度信息: ```matlab function D = floyd_warshall(W) n = size(W, 1); D = W; for k = 1:n for i = 1:n for j = 1:n if D(i,j) > D(i,k)+D(k,j) D(i,j) = D(i,k)+D(k,j); end end end end end ``` --- 问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值