UVA1674 闪电的能量 Lightning Energy Report
problem:
给一个n个节点的树，点有点权（初始为0），在树上进行q次路径加，最后输出每个点的权值
data range:
(N,Q<=10^4)
solution:
可以不用树链剖分
考虑树上差分
设路径的两个端点为u,v，lca为u,v的最近公共祖先，f为lca的父亲
那么我们就可以在u,v上加上权值，在lca上减去权值，在f上再减去一次权值
手推下就好理解了，仅有路径上的点加且仅加了一倍权值
最后再dfs一遍统计答案就行了
Space time complexity:
时间：(O(nlogn))
空间：(O(nlogn))
code:
#include<bits/stdc++.h>
using namespace std;
const int N=5e4+5,H=16;
int t,n,q,sign;
int tin[N],tout[N],fa[N][20],dep[N],val[N];
vector<int>e[N];
void dfs1(int u,int pr)
{
tin[u]=++sign;
dep[u]=dep[pr]+1;fa[u][0]=pr;
for(int i=1;(1<<i)<=dep[u];++i)
fa[u][i]=fa[fa[u][i-1]][i-1];
for(size_t i=0;i<e[u].size();++i)
{
int v=e[u][i];
if(v==pr)continue;
dfs1(v,u);
}
tout[u]=++sign;
}
inline bool isac(int x,int y){return tin[x]<=tin[y]&&tout[y]<=tout[x];}
inline int lca(int x,int y)
{
if(dep[x]>dep[y])swap(x,y);
if(isac(x,y))return x;
for(int i=H;i>=0;--i)
if(!isac(fa[x][i],y))x=fa[x][i];
return fa[x][0];
}
void dfs2(int u,int pr)
{
for(size_t i=0;i<e[u].size();++i)
{
int v=e[u][i];
if(v==pr)continue;
dfs2(v,u);val[u]+=val[v];
}
}
int main()
{
int kase=0;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
fill(val+1,val+n+1,0);
for(int i=1;i<=n;++i)
fill(fa[i],fa[i]+20,0),e[i].clear();
for(int i=1;i<n;++i)
{
int u,v;scanf("%d%d",&u,&v);++u,++v;
e[u].push_back(v);
e[v].push_back(u);
}
sign=0;dfs1(1,0);tin[0]=0,tout[0]=++sign;
scanf("%d",&q);
while(q--)
{
int u,v,c;scanf("%d%d%d",&u,&v,&c);++u,++v;
int lcauv=lca(u,v);
val[u]+=c,val[v]+=c;
val[lcauv]-=c;
if(fa[lcauv][0])val[fa[lcauv][0]]-=c;
}
dfs2(1,0);
printf("Case #%d:
",++kase);
for(int i=1;i<=n;++i)printf("%d
",val[i]);
}
return 0;
}
Rikka与路径的交集(Rikka with Intersection of Paths)
problem:
给出一个n个节点的树以及树上m条路径，要求选择其中k条路径使得这k条路径至少有一个公共点。求选择的方案数
data range:
(N,M<=3*10^5)
(2<=K<=M)
solution:
这题是本次所有题目中最难的。上道题其实是本题的严格弱化（单就所用到的方法来说）
本题计数的难点在于如何做到不重不漏
首先我们定义一条路径的lca就是这条路径两个端点的lca
我们有这样一个神仙定理：
树上两条路径相交，那么交点必然有一个节点为两条路径中某一条的lca
我不会证明，但是可以感性理解
如果不满足以上定理，相交就会是这样的情况（红点为相交处）
显然不可能（树上每个节点（除根节点）都有唯一父亲，而图中红点有两个父亲）
接下来我们将这个定理运用到本题中来
枚举每个节点作为k条路径的交点，当且仅当这k条路径中至少有一条路径的lca为这个节点时我们才统计这种选择
- 为什么这样做不会遗漏？
因为每条路径都对应一个lca，因此不会统计漏
- 为什么这样做不会重复？
考虑某一种选择方案，不妨设其中至少一条路径的lca为u节点
那么这种方案当且仅当枚举到u时才会被统计到，因为每条路径都有且仅有一个lca
现在考虑怎么计算这个东西
假设我们已经对于每个节点u求出有(A_u)条路径以u为lca,有(P_u)条路径经过u节点
那么这个节点的贡献就是(C(P_u,k)-C(P_u-A_u,k))
意思就是所有情况减去不合法情况
对于(A_u)，读入路径时求出lca累加即可
对于(P_u)，完全同上一道题
那么此题就结束了
p.s.至于如何求组合数，我是先预处理阶乘以及阶乘的逆元然后就可以做到(O(1))查询
space time complexity:
时间：(O(nlogn))
空间：(O(nlogn))
code:
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5,H=19,mod=1e9+7;
int n,t,m,k,sign,ans;
int dep[N],fa[N][20],tin[N],tout[N],a[N],p[N];
int fac[N],inv[N];
vector<int>e[N];
inline int add(int x,int y){return x+y>=mod?x+y-mod:x+y;}
inline int dec(int x,int y){return x-y<0?x-y+mod:x-y;}
inline int read()
{
int s=0,w=1; char ch=getchar();
for(;!isdigit(ch);ch=getchar())if(ch=='-')w=-1;
for(;isdigit(ch);ch=getchar())s=(s<<1)+(s<<3)+(ch^48);
return s*w;
}
inline int qpow(int x,int y)
{
int ans=1;
for(;y;y>>=1,x=1ll*x*x%mod)
if(y&1)ans=1ll*ans*x%mod;
return ans;
}
inline void pre(int lim)
{
fac[0]=1;
for(int i=1;i<=lim;++i)fac[i]=1ll*fac[i-1]*i%mod;
inv[lim]=qpow(fac[lim],mod-2);
for(int i=lim-1;~i;--i)inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
inline int C(int x,int y){return x<y?0:1ll*fac[x]*inv[y]%mod*inv[x-y]%mod;}
void dfs(int u,int pr=0)
{
tin[u]=++sign;
dep[u]=dep[pr]+1;fa[u][0]=pr;
for(int i=1;(1<<i)<=dep[u];++i)
fa[u][i]=fa[fa[u][i-1]][i-1];
for(size_t i=0;i<e[u].size();++i)
{
int v=e[u][i];
if(v!=pr)dfs(v,u);
}
tout[u]=++sign;
}
inline bool isac(int x,int y){return tin[x]<=tin[y]&&tout[y]<=tout[x];}
inline int lca(int x,int y)
{
if(dep[x]>dep[y])swap(x,y);
if(isac(x,y))return x;
for(int i=H;~i;--i)
if(!isac(fa[x][i],y))x=fa[x][i];
return fa[x][0];
}
void calc(int u,int pr=0)
{
for(size_t i=0;i<e[u].size();++i)
{
int v=e[u][i];
if(v==pr)continue;
calc(v,u);p[u]+=p[v];
}
ans=add(ans,dec(C(p[u],k),C(p[u]-a[u],k)));
}
int main()
{
pre(N-5);
t=read();
while(t--)
{
n=read(),m=read(),k=read();
for(int i=1;i<=n;++i)
e[i].clear(),fill(fa[i],fa[i]+H+1,0);
for(int i=1;i<n;++i)
{
int x=read(),y=read();
e[x].push_back(y);
e[y].push_back(x);
}
sign=0;dfs(1);tin[0]=0,tout[0]=++sign;
fill(a+1,a+n+1,0),fill(p+1,p+n+1,0);
while(m--)
{
int x=read(),y=read();
int lcaxy=lca(x,y);
++a[lcaxy];
++p[x],++p[y],--p[lcaxy];
if(fa[lcaxy][0])--p[fa[lcaxy][0]];
}
ans=0;calc(1);
printf("%d
",ans);
}
return 0;
}
村庄有多远（How far away? HDU2586）
problem:
给出一颗n个节点的树，m个询问，每次询问树上两点的距离
data range:
(N<=4*10^4)
(M<=200)
solution:
lca模板题（甚至暴力跳lca也不会超时）
space time complexity:
时间&空间：(O(nlogn))
code:
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=4e4+5;
int t,m,n,h,tot,fa[N][20],d[N],dep[N];
int fi[N],ne[N<<1],to[N<<1],w[N<<1];
inline void add(int x,int y,int s)
{
ne[++tot]=fi[x],fi[x]=tot,to[tot]=y,w[tot]=s;
}
void dfs(int x,int pr)
{
dep[x]=dep[pr]+1;fa[x][0]=pr;
for(int i=1;(1<<i)<=dep[x];++i)
fa[x][i]=fa[fa[x][i-1]][i-1];
for(int i=fi[x];i;i=ne[i])
{
int v=to[i];
if(v==pr)continue;
d[v]=d[x]+w[i];
dfs(v,x);
}
}
inline int lca(int x,int y)
{
if(dep[x]<dep[y])swap(x,y);
for(int i=h;i>=0;--i)
if(dep[fa[x][i]]>=dep[y])
x=fa[x][i];
if(x==y)return x;
for(int i=h;i>=0;--i)
if(fa[x][i]!=fa[y][i])
x=fa[x][i],y=fa[y][i];
return fa[x][0];
}
inline int dis(int x,int y)
{
return d[x]+d[y]-d[lca(x,y)]*2;
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
tot=0;fill(fi+1,fi+n+1,0);
h=ceil(log2(n));
for(int i=1;i<n;++i)
{
int x,y,s;scanf("%d%d%d",&x,&y,&s);
add(x,y,s);add(y,x,s);
}
d[1]=dep[0]=0;
dfs(1,0);
while(m--)
{
int x,y;scanf("%d%d",&x,&y);
printf("%d
",dis(x,y));
}
}
return 0;
}
祖孙询问(LOJ10135)
problem:
已知一棵n个节点的有根树。有m个询问，每个询问给出了一对节点的编号x和y，询问x与y的祖孙关系。
data range:
(N,M<=4*10^4)
solution:
可以做到(O(n))预处理(O(1))查询
记下每个节点u进入时的时间(tin_u)和离开时的时间(tout_u)
x是y的祖先当且仅当满足tin[x]<tin[y]&&tout[y]<tout[x]
space time complexity:
时间&空间：(O(n))
code:
#include<bits/stdc++.h>
using namespace std;
const int N=4e4+5;
vector<int>v[N];
int n,m,rt,timer,tin[N],tout[N];
void dfs(int x,int pr)
{
tin[x]=++timer;
for(int i=0;i<v[x].size();++i)
{
int u=v[x][i];
if(u==pr)continue;
dfs(u,x);
}
tout[x]=++timer;
}
inline bool is_ancestor(int x,int y)
{
return tin[x]<tin[y]&&tout[y]<tout[x];
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
int a,b;scanf("%d%d",&a,&b);
if(b==-1){rt=a;continue;}
v[a].push_back(b);
v[b].push_back(a);
}
dfs(rt,-1);
scanf("%d",&m);
while(m--)
{
int a,b;scanf("%d%d",&a,&b);
if(is_ancestor(a,b))puts("1");
else if(is_ancestor(b,a))puts("2");
else puts("0");
}
return 0;
}
Network(POJ3417)
problem:
一棵有n个节点的无根树，再给出m条边，把这m条边连上，每次你能毁掉两条边，规定一条是树边，一条新边。问有多少种方案能使树断裂。
data range:
(N,M<=10^5)
solution:
每加入一条新边，树上就会多一个简单环
对于一条树边，如果它属于这个环，那么我们就称它被所加入的新边覆盖
枚举每条树边，考虑删除这条边
如果这条边没有被新边覆盖，那么删去这条边后再任意删一条新边都满足条件
如果这条边仅被一条新边覆盖，那么删去这条边后只能删去覆盖它的新边才能满足条件
如果这条边被多条新边覆盖，那么这条树边对答案没有贡献
space time complexity:
时间&空间：(O(nlogn))
code:
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<math.h>
#include<cctype>
using namespace std;
const int N=1e5+5;
int n,m,tot,timer,ans,h,fa[N][20],tin[N],tout[N],dep[N];
int fi[N],ne[N<<1],to[N<<1],val[N];
inline int read()
{
int s=0,w=1; char ch=getchar();
for(;!isdigit(ch);ch=getchar())if(ch=='-')w=-1;
for(;isdigit(ch);ch=getchar())s=(s<<1)+(s<<3)+(ch^48);
return s*w;
}
inline void add(int x,int y){ne[++tot]=fi[x],fi[x]=tot,to[tot]=y;}
void dfs(int x,int pr)
{
tin[x]=++timer;
dep[x]=dep[pr]+1;fa[x][0]=pr;
for(int i=1;i<=h;++i)
fa[x][i]=fa[fa[x][i-1]][i-1];
for(int i=fi[x];i;i=ne[i])
{
int v=to[i];
if(v==pr)continue;
dfs(v,x);
}
tout[x]=++timer;
}
inline bool anc(int x,int y){return tin[x]<tin[y]&&tout[y]<tout[x];}
inline int lca(int x,int y)
{
if(x==y)return x;
if(dep[x]>dep[y])swap(x,y);
if(anc(x,y))return x;
for(int i=h;i>=0;--i)
if(!anc(fa[x][i],y))x=fa[x][i];
return fa[x][0];
}
void dfs2(int x,int pr)
{
for(int i=fi[x];i;i=ne[i])
{
int v=to[i];
if(v==pr)continue;
dfs2(v,x);
val[x]+=val[v];
}
if(val[x]==1)++ans;
else if(!val[x])ans+=m;
}
int main()
{
n=read(),m=read();h=(int)(log(n)/log(2))+1;
for(int i=1;i<n;++i)
{
int x=read(),y=read();
add(x,y);add(y,x);
}
for(int i=0;i<=h;++i)fa[1][i]=1;
dfs(1,1);
for(int i=1;i<=m;++i)
{
int x=read(),y=read();
++val[x],++val[y],val[lca(x,y)]-=2;
}
dfs2(1,1);
printf("%d
",ans-m);
return 0;
}
聚会(AHOI 2008)
problem:
大小为N的一棵树上给定3个点A/B/C，找出一个点离这3个点距离之和最小(询问M次)
data range:
(N,M<=5*10^5)
solution:
对这三个点两两求lca
容易发现三个lca中有两个都是相同的
各种画图手玩打表证明不重合的公共点才是最优解
输出答案时可以巧妙地使用异或操作
space time complexity:
时间&空间：(O(nlogn))
code:
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+5;
int n,m,tot,tim;
int fi[N],ne[N<<1],to[N<<1],dep[N],f[N][20],tin[N],tout[N];
inline int read()
{
int s=0,w=1; char ch=getchar();
for(;!isdigit(ch);ch=getchar())if(ch=='-')w=-1;
for(;isdigit(ch);ch=getchar())s=(s<<1)+(s<<3)+(ch^48);
return s*w;
}
inline void add(int x,int y){ne[++tot]=fi[x],fi[x]=tot,to[tot]=y;}
void dfs(int u,int fa)
{
dep[u]=dep[fa]+1;f[u][0]=fa;
for(int i=1;(1<<i)<=dep[u];++i)
f[u][i]=f[f[u][i-1]][i-1];
tin[u]=++tim;
for(int i=fi[u];i;i=ne[i])
{
int v=to[i];
if(v==fa)continue;
dfs(v,u);
}
tout[u]=++tim;
}
inline bool is_Anc(int x,int y){return tin[x]<=tin[y]&&tout[y]<=tout[x];}
inline int lca(int x,int y)
{
if(dep[x]>dep[y])swap(x,y);
if(is_Anc(x,y))return x;
int h=ceil(log2(dep[x]));
for(int i=h;i>=0;--i)
if(!is_Anc(f[x][i],y))
x=f[x][i];
return f[x][0];
}
inline int dis(int x,int y,int Lca){return dep[x]+dep[y]-2*dep[Lca];}
int main()
{
n=read(),m=read();
for(int i=1;i<n;++i)
{
int x=read(),y=read();
add(x,y);add(y,x);
}
dfs(1,0);tin[0]=0,tout[0]=++tim;
while(m--)
{
int x=read(),y=read(),z=read();
int lca1=lca(x,y),lca2=lca(x,z),lca3=lca(y,z);
int d=(dis(x,y,lca1)+dis(x,z,lca2)+dis(y,z,lca3))>>1;
printf("%d %d
",lca1^lca2^lca3,d);
}
return 0;
}
异象石(SDOI2015)
problem:
大小为N的一棵树，M个时刻发生M个事件，类型有三：
1.某个点出现异象石。
2.删除异象石。
3.询问问异象石所在的点连通边集的总长度最小是多少。
data range:
(N<=10^5)
solution:
此题思路很妙啊
考虑按照dfs序维护所有异象石，设sum为相邻两个异象石的距离之和（首尾也算），答案就是sum>>1
具体来说
- 插入x
sum减去dis(pre,nxt),再加上dis(pre,x)+dis(x,nxt)
- 删除x
sum减去dis(pre,x)+dis(x,nxt),再加上dis(pre,nxt)
具体维护用set就可以了，但要特殊处理首尾相邻的情况
这道题还用到了不少关于set的技巧，值得积累
space time complexity:
时间&空间：(O(nlogn))
code:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5,H=17;
int n,dfn[N],dfc,sign,fa[N][20],dep[N];
ll len[N];
int tin[N],tout[N];
struct edge{int to,w;edge(int _to=0,int _w=0){to=_to,w=_w;}};
struct cmp{bool operator()(const int&x,const int&y){return dfn[x]<dfn[y];}};
set<int,cmp>s;
vector<edge>e[N];
void dfs(int u,int pr)
{
tin[u]=++sign,dfn[u]=++dfc;
fa[u][0]=pr,dep[u]=dep[pr]+1;
for(int i=1;(1<<i)<=dep[u];++i)
fa[u][i]=fa[fa[u][i-1]][i-1];
for(size_t i=0;i<e[u].size();++i)
{
edge v=e[u][i];
if(v.to==pr)continue;
len[v.to]=len[u]+1ll*v.w;
dfs(v.to,u);
}
tout[u]=++sign;
}
inline bool isac(int x,int y){return tin[x]<=tin[y]&&tout[y]<=tout[x];}
inline int lca(int x,int y)
{
if(dep[x]>dep[y])swap(x,y);
if(isac(x,y))return x;
for(int i=H;i>=0;--i)
if(!isac(fa[x][i],y))
x=fa[x][i];
return fa[x][0];
}
inline ll dis(int x,int y)
{
int LCA=lca(x,y);
return len[x]+len[y]-2*len[LCA];
}
inline int pre(int x)
{
set<int,cmp>::iterator it=s.lower_bound(x);
if(it==s.begin())return *s.rbegin();
it--;return *it;
}
inline int nxt(int x)
{
set<int,cmp>::iterator it=s.lower_bound(x);
it++;if(it==s.end())return *s.begin();
return *it;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<n;++i)
{
int x,y,z;scanf("%d%d%d",&x,&y,&z);
e[x].push_back(edge(y,z));
e[y].push_back(edge(x,z));
}
len[1]=0;dfs(1,0);tin[0]=0,tout[0]=++sign;
int m;scanf("%d",&m);
char ch[5];int x;ll ans=0;
while(m--)
{
scanf("%s",ch);
if(ch[0]=='?')printf("%lld
",ans>>1);
else
{
scanf("%d",&x);
if(ch[0]=='+')
{
s.insert(x);
int l=pre(x),r=nxt(x);
ans-=dis(l,r);
ans+=dis(l,x)+dis(x,r);
}
else
{
int l=pre(x),r=nxt(x);
ans-=dis(l,x)+dis(x,r);
ans+=dis(l,r);
s.erase(x);
}
}
}
return 0;
}