bzoj 3052: [wc2013]糖果公园 带修改莫队
3052: [wc2013]糖果公园
Time Limit: 250 Sec Memory Limit: 512 MB
Submit: 506 Solved: 189
[Submit][Status]
Description
Input
Output
Sample Input
Sample Input
Sample Output
131
27
84
HINT
本来这道题想到了莫队算法，但是看到带修改就直接放弃了。结果看题解才发现带修改居然也能用莫队！！！之所以可以这样用，是因为修改的时间复杂度非常非常低，以至于可以在修改的时间轴上任意跳跃。具体细节自己去看其他题解啦。
写的有点长，但是跑的还算比较快。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 100100
#define MAXB 2200
#define MAXQ 100100
#define MAXV MAXN
#define MAXE MAXV*2
typedef long long qword;
inline int nextInt()
{
register int x=;
register int ch;
while (ch=getchar(),ch<'' || ch>'');
while (x=x*+ch-'',ch=getchar(),ch<='' && ch>='');
return x;
}
int n,m,q,sb;
struct Edge
{
int np;
Edge *next;
}E[MAXE],*V[MAXV];
int tope=-;
int que[MAXN];
void addedge(int x,int y)
{
E[++tope].np=y;
E[tope].next=V[x];
V[x]=&E[tope];
}
int depth[MAXN];
int pnt[MAXN];
int top[MAXN],bsiz[MAXN];
int belong[MAXN];
int topb=;
void bfs1()
{
Edge *ne;
int now;
int head=-,tail=;
que[]=;
pnt[]=;
belong[]=++topb;
top[]=;
bsiz[]=;
depth[]=;
while (head<tail)
{
now=que[++head];
for (ne=V[now];ne;ne=ne->next)
{
if (ne->np==pnt[now])continue;
que[++tail]=ne->np;
pnt[ne->np]=now;
depth[ne->np]=depth[now]+;
if (bsiz[belong[now]]<sb)
{
bsiz[belong[now]]++;
belong[ne->np]=belong[now];
top[ne->np]=top[now];
}else
{
belong[ne->np]=++topb;
bsiz[topb]=;
top[ne->np]=ne->np;
}
}
}
}
int jump[][MAXN];
void init_lca()
{
for (int i=;i<=n;i++)
jump[][i]=pnt[i];
for (int j=;j<;j++)
for (int i=;i<=n;i++)
jump[j][i]=jump[j-][jump[j-][i]];
}
int lca(int x,int y)
{
if (depth[x]<depth[y])swap(x,y);
int dep=depth[x]-depth[y];
for (int i=;i<;i++)
if (dep & (<<i))
x=jump[i][x];
if (x==y)return x;
for (int i=;i>=;i--)
if (jump[i][x]!=jump[i][y])
x=jump[i][x],y=jump[i][y];
return pnt[x];
}
int get_dis(int x,int y)
{
return depth[x]+depth[y]-*depth[lca(x,y)];
}
struct qur_t
{
int s,t,id;
int upper_pos;
qword ans;
}qur[MAXQ];
int topq=-;
bool cmp_qur_block(qur_t a1,qur_t a2)
{
if (belong[a1.s]!=belong[a2.s])
return belong[a1.s]<belong[a2.s];
if (belong[a1.t]!=belong[a2.t])
return belong[a1.t]<belong[a2.t];
return a1.id<a2.id;
}
bool cmp_qur_id(qur_t a1,qur_t a2)
{
return a1.id<a2.id;
}
int sweet[MAXN];
qword suprise[MAXN];
int candy[MAXN];
struct mdfy_t
{
int pos,cnew,cold,id;
}mdfy[MAXN];
int topm=-;
struct path
{
int s,t,a,ds;
path(int s,int t):s(s),t(t)
{
a=lca(s,t);
ds=depth[s]+depth[t]-*depth[a];
}
path(){}
bool inside(int x)
{
return get_dis(x,s)+get_dis(x,t)==ds;
}
void get_path(int *step,int &tops)
{
tops=-;
for (int x=s;x!=a;x=pnt[x])
step[++tops]=x;
tops=ds;
for (int x=t;x!=a;x=pnt[x])
step[tops--]=x;
step[tops--]=a;
tops=ds;
}
};
int tot[MAXN];
bool inside[MAXN];
int step[MAXN],tops;
int main()
{
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int x,y,z;
n=nextInt(),m=nextInt(),q=nextInt();
sb=pow(n,2.0/);
for (int i=;i<=m;i++)
sweet[i]=nextInt();
for (int i=;i<=n;i++)
suprise[i]=nextInt();
for (int i=;i<=n;i++)suprise[i]+=suprise[i-];
for (int i=;i<n;i++)
{
x=nextInt(),y=nextInt();
addedge(x,y);
addedge(y,x);
}
for (int i=;i<=n;i++)
candy[i]=nextInt();
int opt;
for (int i=;i<=q;i++)
{
opt=nextInt();
if (opt==)
{
x=nextInt(),y=nextInt();
++topm;
mdfy[topm].pos=x;
mdfy[topm].cnew=y;
mdfy[topm].cold=candy[x];
candy[x]=y;
mdfy[topm].id=i;
}else
{
x=nextInt(),y=nextInt();
++topq;
qur[topq].s=x;
qur[topq].t=y;
qur[topq].upper_pos=topm+;
qur[topq].id=i;
}
}
for (int i=topm;i>=;i--)
candy[mdfy[i].pos]=mdfy[i].cold;
bfs1();
init_lca();
sort(qur,qur+topq+,cmp_qur_block);
for (int i=;i<qur[].upper_pos;i++)
candy[mdfy[i].pos]=mdfy[i].cnew;
int a;
a=lca(qur[].s,qur[].t);
qword nsum=;
for (x=qur[].s;x!=a;x=pnt[x])
{
inside[x]=true;
tot[candy[x]]++;
nsum+=(suprise[tot[candy[x]]]-suprise[tot[candy[x]]-])*sweet[candy[x]];
}
for (y=qur[].t;;y=pnt[y])
{
inside[y]=true;
tot[candy[y]]++;
nsum+=(suprise[tot[candy[y]]]-suprise[tot[candy[y]]-])*sweet[candy[y]];
if (y==a)break;
}
qur[].ans=nsum;
path pnow(qur[].s,qur[].t);
path pwalk;
for (int i=;i<=topq;i++)
{
for (int kk=;kk<;kk++)
{
if (kk==)
pwalk=path(qur[i-].s,qur[i].s);
else
pwalk=path(qur[i-].t,qur[i].t);
pwalk.get_path(step,tops);
bool flag=true;
for (int j=;j<=tops+;j++)
{
if (j!=tops+ && inside[step[j]])
{
inside[step[j]]=false;
tot[candy[step[j]]]--;
nsum+=(suprise[tot[candy[step[j]]]]-suprise[tot[candy[step[j]]]+])*sweet[candy[step[j]]];
}else
{
if (flag)
{
inside[step[j-]]=true;
tot[candy[step[j-]]]++;
nsum+=(suprise[tot[candy[step[j-]]]]-suprise[tot[candy[step[j-]]]-])*sweet[candy[step[j-]]];
flag=false;
}
if (j==tops+)break;
inside[step[j]]=true;
tot[candy[step[j]]]++;
nsum+=(suprise[tot[candy[step[j]]]]-suprise[tot[candy[step[j]]]-])*sweet[candy[step[j]]];
}
}
}
if (qur[i-].upper_pos<qur[i].upper_pos)
{
for (int j=qur[i-].upper_pos;j<qur[i].upper_pos;j++)
{
if (candy[mdfy[j].pos]!=mdfy[j].cold)throw;
candy[mdfy[j].pos]=mdfy[j].cnew;
if (inside[mdfy[j].pos])
{
tot[mdfy[j].cold]--;
nsum+=(suprise[tot[mdfy[j].cold]]-suprise[tot[mdfy[j].cold]+])*sweet[mdfy[j].cold];
tot[mdfy[j].cnew]++;
nsum+=(suprise[tot[mdfy[j].cnew]]-suprise[tot[mdfy[j].cnew]-])*sweet[mdfy[j].cnew];
}
}
}else
{
for (int j=qur[i-].upper_pos-;j>=qur[i].upper_pos;j--)
{
if (candy[mdfy[j].pos]!=mdfy[j].cnew)throw;
candy[mdfy[j].pos]=mdfy[j].cold;
if (inside[mdfy[j].pos])
{
tot[mdfy[j].cnew]--;
nsum+=(suprise[tot[mdfy[j].cnew]]-suprise[tot[mdfy[j].cnew]+])*sweet[mdfy[j].cnew];
tot[mdfy[j].cold]++;
nsum+=(suprise[tot[mdfy[j].cold]]-suprise[tot[mdfy[j].cold]-])*sweet[mdfy[j].cold];
}
}
}
qur[i].ans=nsum;
}
sort(qur,qur+topq+,cmp_qur_id);
for (int i=;i<=topq;i++)
printf("%lld\n",qur[i].ans);
}
bzoj 3052: [wc2013]糖果公园 带修改莫队的更多相关文章
- [BZOJ 3052] [wc2013] 糖果公园 【树上莫队】
题目链接:BZOJ - 3052 题目分析 这道题就是非常经典的树上莫队了,并且是带修改的莫队. 带修改的莫队:将询问按照 左端点所在的块编号为第一关键字,右端点所在的块为第二关键字,位于第几次修改之 ...
- BZOJ.3052.[WC2013]糖果公园(树上莫队 带修改莫队)
题目链接 BZOJ 当然哪都能交(都比在BZOJ交好),比如UOJ #58 //67376kb 27280ms //树上莫队+带修改莫队 模板题 #include <cmath> #inc ...
- 【bzoj3052】[wc2013]糖果公园 带修改树上莫队
题目描述 给出一棵n个点的树,每个点有一个点权,点权范围为1~m.支持两种操作:(1)修改一个点的点权 (2)对于一条路径,求$\sum\limits_{i=1}^m\sum\limits_{j=1} ...
- BZOJ.2453.维护队列([模板]带修改莫队)
题目链接 带修改莫队: 普通莫队的扩展,依旧从[l,r,t]怎么转移到[l+1,r,t],[l,r+1,t],[l,r,t+1]去考虑 对于当前所在的区间维护一个vis[l~r]=1,在修改值时根据是 ...
- 【BZOJ3052】[wc2013]糖果公园 带修改的树上莫队
[BZOJ3052][wc2013]糖果公园 Description Input Output Sample Input Sample Input Sample Output 84 131 27 84 ...
- bzoj 2120: 数颜色【带修改莫队】
比较裸的带修莫队,对每个修改操作记一下它修改的位置修改前的颜色 然后正常莫队,每次对修改操作时间倒流一下即可 #include<iostream> #include<cstdio&g ...
- BZOJ 2120 数颜色 【带修改莫队】
任意门:https://www.lydsy.com/JudgeOnline/problem.php?id=2120 2120: 数颜色 Time Limit: 6 Sec Memory Limit: ...
- BZOJ 2120 数颜色（带修改莫队）
[题目链接] http://www.lydsy.com/JudgeOnline/problem.php?id=2120 [题目大意] 给出一颜色序列,每次可以修改一个位置的颜色或者询问一个区间不同颜色 ...
- BZOJ3052 [wc2013] 糖果公园 【树上莫队】
树上莫队和普通的序列莫队很像,我们把树进行dfs,然后存一个长度为2n的括号序列,就是一个点进去当作左括号,出来当作右括号,然后如果访问从u到v路径,我们可以转化成括号序列的区间,记录x进去的时候编号 ...
随机推荐
- 获取随机颜色js
获取随机颜色方法一: function randomColor1() { var rand = Math.floor(Math.random() * 0xFFFFFF).toString(16); i ...
- VS的一部分快捷键
快捷键 功能CTRL + SHIFT + B 生成解决方案CTRL + F ...
- 使用canvas制作在线画板
canvas绘图的强大功能,让人前仆后继的去研究它.代码全部加起来不足百行.还用到了h5中的<input type="color"/>和<input type=& ...
- c#面向对象编程基础
1. 为什么要有面向对象? (1) 增加代码重用. (2)降低维护负担,将具备独特性质的代码封装起来,修改程序时,相互不会影响. 2.数据封装用来解决全局变量不易维护的问题. 3.多态: ...
- 游标、type使用示例
declare my_cur sys_refcursor; --定义游标变量 type v_record is record( --定义 record类型 obj_id number, ...
- 类库探源——System.Math 和 Random
一.System.Math Math类:为三角函数.对数函数和其他通用数学函数提供常数和静态方法 命名空间: System 程序集 : mscorlib.dll 继承关系: 常用属性: Math. ...
- 在Windows下用gSoap实现简单加法实例
实现一个简单的a+b程序,在服务器端写一个程序,里面包含了a+b的函数,然后通过客户端代码向其发送两个数字,在服务器运算得到结果返回给客户端显示出来. 1.在gSoap的官网上下载文件夹,本人的版本是 ...
- 第16章 网络IPC：套接字总结
1 套接字是通信端点的抽象 创建套接字: int socket(int domain,int type,int protocol) domain:通信域 AF_INET.AF_INET6.AF_LOC ...
- C#面向对象的学习笔记
1.面向对象的3要素: 封装:将不需要显示的代码封装到一个方法中,只对外提供方法名,用户不需关心内部实现. 继承:子类继承父类,公用父类的代码,大大提高了代码的重用,贴近生活也符合人类的编程思想. 多 ...
- C#事件作用和用法
例如有下面的需求需要实现:程序主画面中弹出一个子窗口.此时主画面仍然可以接收用户的操作(子窗口是非模态的).子窗口上进行某些操作,根据操作的结果要在主画面上显示不同的数据. 即如下图所示: 大多数我们 ...