test20190504 行走
行走(walk.cpp/c/pas)
题目描述
“我有个愿望，我希望走到你身边。”
这是个奇异的世界，世界上的 n-1 条路联结起来形成一棵树，每条路有一个对应的权值 ci。
现在我会给出 q 组询问或操作。
每次询问我会从一个 x 点走到 y 点，初始在 x 点我会有一个数字 v，然后每走过一条权值为 c 的边，我的 v
就会变成\(\lfloor \frac vc \rfloor\) ,问最后到 y 时 v 变成了什么。
每次修改我会修改一条边的权值，保证修改后的权值小于等于原来的权值且不会小于 1。
每组询问或操作的格式如下：
询问：1 x y v 表示从 x 走到 y，一开始的数字为 v。
操作：2 p c 表示将第 p 条边的边权修改为 c
输入
第一行两个整数 n 和 q 表示点个数和询问与操作个数
接下来 n-1 行每行三个整数 u,v,c 表示 u 与 v 之间有一条边权为 c 的边
接下来 q 行每行第一个数 type
如果 type=1 那么接下来三个数 x,y,v 表示一组询问
如果 type=2 那么接下来两个数 p,c 表示一组操作
输出
对于每组询问输出一个数表示最后的答案
样例输入 1
6 6
1 2 1
1 3 7
1 4 4
2 5 5
2 6 2
1 4 6 17
2 3 2
1 4 6 17
1 5 5 20
2 4 1
1 5 1 3
样例输出 1
2
4
20
3
样例输入 2
5 4
1 2 7
1 3 3
3 4 2
3 5 5
1 4 2 100
1 5 4 1
2 2 2
1 1 3 4
样例输出 2
2
0
2
数据范围
对于 70%的数据保证\(1\le n\le 2000\)
对于 100%的数据保证\(1\le n \le 100000,1\le c_i\le 10^{18}\)
保证每次修改后的边权小于等于原来的边权且不会小于 1
分析
考场做法
如果走过的边权不是1，每次至少除2，只有\(log_2n\)次有效操作。直觉想法是把边权为1的边连接的点用并查集连起来，缩成一个等效点。
但这样做有一个问题，那就是向上跳可以直接跳fa，向下跳呢？于是我想出来用set维护边，给边附加一个maxdfn信息，然后二分查找，这样就不会被菊花图卡了。
然后觉得代码不止一点恶心，颓了半小时，终于狠下心来写完了，然后改了一会过了样例，简直不敢相信自己的眼睛。
时间复杂度\(O(n\log n+q\log v\log n)\)
#include<bits/stdc++.h>
#define co const
template<class T>T read(){
T data=0,w=1;
char ch=getchar();
while(!isdigit(ch)) {if(ch=='-') w=-1;ch=getchar();}
while(isdigit(ch)) data=data*10+ch-'0',ch=getchar();
return data*w;
}
template<class T>T read(T&x){
return x=read<T>();
}
typedef long long ll;
using namespace std;
co int N=1e5+1;
int n,m;
struct org_edge{int x,y;ll c;}oe[N]; // real
struct edge{ // vitual
int mxp,to;ll c;
bool operator<(co edge&e)co{
return mxp!=e.mxp?mxp<e.mxp:to<e.to;
}
};
set<edge> e[N];
typedef set<edge>::iterator it;
int dep[N],pos[N],dfn,fa[N][18];ll val[N];
void dfs(int x,int fa){ // real
dep[x]=dep[fa]+1,pos[x]=++dfn,::fa[x][0]=fa;
for(int i=1;i<=17;++i) ::fa[x][i]=::fa[::fa[x][i-1]][i-1];
set<edge> s;
for(it i=e[x].begin();i!=e[x].end();++i){
int y=i->to;
if(y==fa) {val[x]=i->c;continue;}
dfs(y,x),s.insert((edge){dfn,y,i->c});
}
swap(e[x],s);
}
int lca(int x,int y){ // real
if(dep[x]<dep[y]) swap(x,y);
for(int i=17;i>=0;--i)
if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
if(x==y) return x;
for(int i=17;i>=0;--i)
if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
return fa[x][0];
}
int pa[N];
int find(int x) {return x==pa[x]?x:pa[x]=find(pa[x]);}
void link(int x,int y){ // virtual
assert(x==find(x)),assert(y==find(::fa[x][0]));
pa[x]=y;
it i=e[y].lower_bound((edge){pos[x],0,0});
assert(pos[x]<=i->mxp),e[y].erase(i);
for(i=e[x].begin();i!=e[x].end();++i) e[y].insert(*i);
e[x].clear();
}
ll query(int x,int y,ll v){ // real->virtual
int f=lca(x,y);
x=find(x),y=find(y),f=find(f);
for(;v&&x!=f;x=find(::fa[x][0])) v/=val[x];
if(!v) return 0;
assert(x==f);
for(it i;v&&x!=y;x=i->to){
i=e[x].lower_bound((edge){pos[y],0,0});
v/=i->c;
}
return v;
}
void change(int p,ll c){ // real->virtual
int x=find(oe[p].x),y=find(oe[p].y);
if(x==y) return assert(c==1);
if(dep[x]>dep[y]) swap(x,y);
assert(x==find(::fa[y][0]));
it i=e[x].lower_bound((edge){pos[y],0,0});
assert(pos[y]<=i->mxp),e[x].erase(i),e[x].insert((edge){i->mxp,i->to,c}),val[y]=c;
if(c==1) link(y,x);
}
int main(){
freopen("walk.in","r",stdin),freopen("walk.out","w",stdout);
read(n),read(m);
for(int i=1;i<n;++i){
read(oe[i].x),read(oe[i].y),read(oe[i].c);
e[oe[i].x].insert((edge){0,oe[i].y,oe[i].c});
e[oe[i].y].insert((edge){0,oe[i].x,oe[i].c});
}
dfs(1,0);
for(int i=1;i<=n;++i) pa[i]=i;
for(int i=1;i<=n;++i)if(val[i]==1) link(i,find(::fa[i][0]));
while(m--){
if(read<int>()==1){
int x,y;ll v;
read(x),read(y),read(v);
printf("%lld\n",query(x,y,v));
}
else{
int p;ll c;
read(p),read(c);
change(p,c);
}
}
return 0;
}
刘哥做法
打表得到性质，下取整除法可以结合（意会），并且要证明的话是显然的。
于是树剖线段树维护路径乘积，维护一下溢出标记，然后每次把路径找出来就行了。
时间复杂度\(O(n+m\log^n)\)
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
inline ll read()
{
ll x=0,k=1;
char ch=getchar();
while(ch<'0'||ch>'9')
{
if(ch=='-') k=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
x=x*10+ch-'0';
ch=getchar();
}
return k*x;
}
const int MAXN=2e5+10;
int n,Q;
int ecnt=0,head[MAXN],to[MAXN<<1],nx[MAXN<<1],fa[MAXN];
ll val[MAXN<<1],vf[MAXN];
int dep[MAXN];
int U[MAXN],V[MAXN];
inline void addedge(int u,int v,ll w)
{
++ecnt;
to[ecnt]=v;
nx[ecnt]=head[u];
val[ecnt]=w;
head[u]=ecnt;
}
ll wp[MAXN];
int dfn[MAXN],dfnidx=0,rnk[MAXN],siz[MAXN],mxson[MAXN],top[MAXN];
void dfs1(int u,int f)
{
fa[u]=f;
siz[u]=1;
dep[u]=dep[f]+1;
for(int i=head[u]; i; i=nx[i])
{
int v=to[i];
if(v==f)
continue;
dfs1(v,u);
siz[u]+=siz[v];
if(siz[v]>siz[mxson[u]])
mxson[u]=v;
}
}
void dfs2(int u,int tp)
{
dfn[u]=++dfnidx;
rnk[dfnidx]=u;
top[u]=tp;
if(mxson[u])
dfs2(mxson[u],tp);
for(int i=head[u]; i; i=nx[i])
{
int v=to[i];
if(v!=mxson[u] && v!=fa[u])
dfs2(v,v);
}
}
ll prod[MAXN<<2];
#define root prod[o]
#define lson prod[o<<1]
#define rson prod[o<<1|1]
void pushup(int o)
{
root=lson*rson;
root=max(root,0LL);
}
void bd(int o,int l,int r)
{
if(l==r)
{
root=wp[rnk[l]];
return;
}
int mid=(l+r)>>1;
bd(o<<1,l,mid);
bd(o<<1|1,mid+1,r);
pushup(o);
}
void update(int o,int l,int r,int pos,ll c)
{
if(l==r)
{
root=c;
return;
}
int mid=(l+r)>>1;
if(pos<=mid)
update(o<<1,l,mid,pos,c);
else
update(o<<1|1,mid+1,r,pos,c);
pushup(o);
}
ll query(int o,int l,int r,int L,int R)
{
ll res=1;
if(l>R || L>r)
return 1;
if(L<=l && r<=R)
return max(0LL,root);
int mid=(l+r)>>1;
if(L<=mid)
{
res*=query(o<<1,l,mid,L,R);
res=max(res,0LL);
}
if(R>mid)
{
res*=query(o<<1|1,mid+1,r,L,R);
res=max(res,0LL);
}
return res;
}
void solve()
{
int idx=n;
for(int i=1; i<n; ++i)
{
int u=read(),v=read();
ll w=read();
++idx;
addedge(u,idx,0);
addedge(idx,u,0);
addedge(idx,v,0);
addedge(v,idx,0);
wp[idx]=w;
}
for(int i=1; i<=n; ++i)
wp[i]=1;
dfs1(1,0);
dfs2(1,1);
bd(1,1,idx);
while(Q--)
{
int tp=read();
if(tp==1)
{
int x=read(),y=read();
ll v=read();
while(top[x]!=top[y])
{
if(dep[top[x]]<dep[top[y]])
swap(x,y);
ll p=query(1,1,idx,dfn[top[x]],dfn[x]);
if(p<=0)
{
puts("0");
continue;
}
v/=p;
x=fa[top[x]];
}
if(dep[x]<dep[y])
swap(x,y);
ll p=query(1,1,idx,dfn[y],dfn[x]);
if(p<=0)
{
puts("0");
continue;
}
v/=p;
printf("%lld\n",v);
}
else
{
int p=read();
ll c=read();
update(1,1,idx,dfn[p+n],c);
}
}
}
void dfs(int u,int f)
{
fa[u]=f;
for(int i=head[u]; i; i=nx[i])
{
int v=to[i];
if(v==f)
continue;
dep[v]=dep[u]+1;
vf[v]=val[i];
dfs(v,u);
}
}
int bf()
{
for(int i=1; i<n; ++i)
{
int u=read(),v=read();
ll w=read();
U[i]=u,V[i]=v;
addedge(u,v,w);
addedge(v,u,w);
}
dfs(1,0);
while(Q--)
{
int tp=read();
if(tp==1)
{
int x=read(),y=read();
ll v=read();
while(x!=y)
{
if(dep[x]>dep[y])
v/=vf[x],x=fa[x];
else
v/=vf[y],y=fa[y];
}
printf("%lld\n",v);
}
else
{
int p=read();
ll v=read();
if(fa[U[p]]==V[p])
vf[U[p]]=v;
else
vf[V[p]]=v;
}
}
return 0;
}
int main()
{
freopen("walk.in","r",stdin);
freopen("walk.out","w",stdout);
n=read();
Q=read();
if(n<=1000)
return bf();
solve();
return 0;
}
std做法
其实往下跳没有必要了。过了lca以后仍然从另一边往上跳，溢出及时跳出就行了。这样也最多\(\log_2 v\)次
标程暂缺。陈年老题，估计也不会有了。
放上前辈的代码。
//QWsin
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=100000+10;
const int maxm=200000+10;
int n,Q;
int first[maxn],next[maxm],ecnt=0;
struct Edge{int u,v;ll w;Edge(int u=0,int v=0,ll w=0):u(u),v(v),w(w){}}e[maxm];
inline void add_edge(int u,int v,ll w)
{
next[ecnt]=first[u];first[u]=ecnt;e[ecnt++]=Edge(u,v,w);
next[ecnt]=first[v];first[v]=ecnt;e[ecnt++]=Edge(v,u,w);
}
int dep[maxn],fa[maxn],faid[maxn];
void dfs(int u,int pre,int deep)
{
dep[u]=deep;
for(int i=first[u];i!=-1;i=next[i])
if(e[i].v!=pre)
{
fa[e[i].v]=u;faid[e[i].v]=i;
dfs(e[i].v,u,deep+1);
}
}
ll query(int a,int b,ll c)
{
if(dep[a] > dep[b]) swap(a,b);
if(dep[a] < dep[b]){
for(;dep[a]<dep[b];b=fa[b])
if((c/=e[faid[b]].w)==0) return 0;
}
if(a!=b)
{
for(;a!=b;a=fa[a],b=fa[b]){
if((c/=e[faid[b]].w)==0) return 0;
if((c/=e[faid[a]].w)==0) return 0;
}
}
return c;
}
int main()
{
freopen("walk.in","r",stdin);
freopen("walk.out","w",stdout);
cin>>n>>Q;ll w;
memset(first,-1,sizeof first);
for(int i=1,u,v;i<n;++i) {
scanf("%d%d%lld",&u,&v,&w);add_edge(u,v,w);
}
dfs(1,1,1);
int op,a,b;ll c;
while(Q--)
{
scanf("%d",&op);
if(op==1) {
scanf("%d%d%lld",&a,&b,&c);
printf("%lld\n",query(a,b,c));
}
else{
scanf("%d%lld",&a,&c);
e[a*2-1].w=e[a*2-2].w=c;
}
}
return 0;
}
静渊以有谋，疏通而知事。
