【bzoj3545/bzoj3551】[ONTAK2010]Peaks/加强版 Kruskal+树上倍增+Dfs序+主席树

bzoj3545

题目描述

在Bytemountains有N座山峰，每座山峰有他的高度h_i。有些山峰之间有双向道路相连，共M条路径，每条路径有一个困难值，这个值越大表示越难走，现在有Q组询问，每组询问询问从点v开始只经过困难值小于等于x的路径所能到达的山峰中第k高的山峰，如果无解输出-1。

输入

第一行三个数N，M，Q。
第二行N个数，第i个数为h_i
接下来M行，每行3个数a b c，表示从a到b有一条困难值为c的双向路径。
接下来Q行，每行三个数v x k，表示一组询问。

输出

对于每组询问，输出一个整数表示答案。

样例输入

10 11 4

1 2 3 4 5 6 7 8 9 10

1 4 4

2 5 3

9 8 2

7 8 10

7 1 4

6 7 1

6 4 8

2 1 5

10 8 10

3 4 7

3 4 6

1 5 2

1 5 6

1 5 8

8 9 2

样例输出

6

1

-1

8

bzoj3551

输入

接下来Q行，每行三个数v x k，表示一组询问。v=v xor lastans，x=x xor lastans，k=k xor lastans。如果lastans=-1则不变。

题解

Kruskal+倍增算法+dfs序+主席树

p3445允许离线，所以还可以用Treap启发式合并。

然而p3451强制在线，这样做肯定不行。

首先肯定是先Kruskal求最小生成树，而一般的最小生成树也无法表示任意两点间距离最大值。

这里用到一个黑科技：Kruskal重构树。

在求最小生成树时，不直接连接两个节点，而是将两个节点的祖先连接到一个新的节点上。

这个新的节点与这两个节点之间的边权就是边的长度。

这有什么好处？



上图是按照这种方式重构的一棵树，其中节点1~10为原节点，11~19为新加节点。

可以看出，从下至上的路径，边权是单调不减的（看作点权即大根堆）。

那么，想要寻找路径小于等于x的所有能到达的点，就可以从最下方的原节点向上查找最远的路径小于x的点，这个点的子树就是所求的点集合。

题目要求这个点集合里第k大的，需要使这些点连续出现，于是想到Dfs序。

我们可以构建一个Dfs序，然后使用主席树来维护并查询第k大。

需要注意的是这两道题都需要读入优化，否则会TLE。

以下为p3545的代码，若为p3551，只需要在询问时修改一小部分即可。

#include <cstdio>
#include <algorithm>
using namespace std;
struct node
{
int x , y , z;
}e[500005];
struct data
{
int num , rank;
}a[200005];
int f[200005] , log[200005] , fa[200005][18] , dis[200005][18] , deep[200005];
int head[200005] , to[200005] , val[200005] , next[200005] , cnt;
int lp[200005] , rp[200005] , pl , q[400005] , ref[200005] , top;
int ls[6000005] , rs[6000005] , si[6000005] , root[400005] , tot;
inline int read()
{
int num = 0; char ch;
while(ch < '0' || ch > '9') ch = getchar();
while(ch >= '0' && ch <= '9') num = num * 10 + ch - '0' , ch = getchar();
return num;
}
bool cmp1(data a , data b)
{
return a.num < b.num;
}
bool cmp2(data a , data b)
{
return a.rank < b.rank;
}
bool cmp3(node a , node b)
{
return a.z < b.z;
}
int find(int x)
{
return x == f[x] ? x : f[x] = find(f[x]);
}
void add(int x , int y , int z)
{
to[++cnt] = y;
val[cnt] = z;
next[cnt] = head[x];
head[x] = cnt;
}
void dfs(int x)
{
int i;
lp[x] = ++pl;
q[pl] = a[x].num;
for(i = head[x] ; i ; i = next[i])
{
if(to[i] != fa[x][0])
{
fa[to[i]][0] = x;
deep[to[i]] = deep[x] + 1;
dfs(to[i]);
}
}
rp[x] = ++pl;
}
void init(int n)
{
int i , j;
for(i = 2 ; i <= n ; i ++ )
log[i] = log[i >> 1] + 1;
for(i = 1 ; i <= log
; i ++ )
for(j = 1 ; j <= n ; j ++ )
if(deep[j] >= (1 << i))
fa[j][i] = fa[fa[j][i - 1]][i - 1] , dis[j][i] = max(dis[j][i - 1] , dis[fa[j][i - 1]][i - 1]);
}
void pushup(int x)
{
si[x] = si[ls[x]] + si[rs[x]];
}
void ins(int x , int &y , int l , int r , int p)
{
y = ++tot;
if(l == r)
{
si[y] = si[x] + 1;
return;
}
int mid = (l + r) >> 1;
if(p <= mid) rs[y] = rs[x] , ins(ls[x] , ls[y] , l , mid , p);
else ls[y] = ls[x] , ins(rs[x] , rs[y] , mid + 1 , r , p);
pushup(y);
}
int query(int x , int y , int l , int r , int p)
{
if(l == r) return ref[l];
int mid = (l + r) >> 1;
if(si[ls[y]] - si[ls[x]] >= p) return query(ls[x] , ls[y] , l , mid , p);
else return query(rs[x] , rs[y] , mid + 1 , r , p - si[ls[y]] + si[ls[x]]);
}
int main()
{
int n , m , qu , i , tx , ty , v , x , k;
n = read() , m = read() , qu = read();
for(i = 1 ; i <= n ; i ++ )
a[i].num= read() , a[i].rank = i;
sort(a + 1 , a + n + 1 , cmp1);
ref[0] = 0x8000000;
for(i = 1 ; i <= n ; i ++ )
{
if(a[i].num != ref[top]) ref[++top] = a[i].num;
a[i].num = top;
}
sort(a + 1 , a + n + 1 , cmp2);
for(i = 1 ; i <= n << 1 ; i ++ )
f[i] = i;
for(i = 1 ; i <= m ; i ++ )
e[i].x = read() , e[i].y = read() , e[i].z = read();
sort(e + 1 , e + m + 1 , cmp3);
for(i = 1 ; i <= m ; i ++ )
{
tx = find(e[i].x) , ty = find(e[i].y);
if(tx != ty)
{
f[tx] = f[ty] = ++n;
fa[tx][0] = fa[ty][0] = n;
dis[tx][0] = dis[ty][0] = e[i].z;
add(n , tx , e[i].z);
add(n , ty , e[i].z);
}
}
dfs(n);
init(n);
for(i = 1 ; i <= pl ; i ++ )
{
if(!q[i]) root[i] = root[i - 1];
else ins(root[i - 1] , root[i] , 1 , top , q[i]);
}
while(qu -- )
{
v = read() , x = read() , k = read();
tx = v;
for(i = log[deep[v]] + 1 ; i >= 0 ; i -- )
if(deep[tx] >= (1 << i) && dis[tx][i] <= x)
tx = fa[tx][i];
printf("%d\n" , si[root[rp[tx]]] - si[root[lp[tx]]] >= k ? query(root[lp[tx]] , root[rp[tx]] , 1 , top , si[root[rp[tx]]] - si[root[lp[tx]]] - k + 1) : -1);
}
return 0;
}