Does Heavy Light Decomposition have any advantage over Binary Lifting Technique or using a sparse table? Can we solve some type of problem using HLD which can't be solved using the other mentioned techniques?

# | User | Rating |
---|---|---|

1 | tourist | 3496 |

2 | Um_nik | 3337 |

3 | Petr | 3298 |

4 | W4yneb0t | 3218 |

5 | Radewoosh | 3216 |

6 | OO0OOO00O0OOO0O0…O | 3188 |

7 | Syloviaely | 3168 |

8 | izrak | 3109 |

9 | anta | 3106 |

10 | fateice | 3099 |

# | User | Contrib. |
---|---|---|

1 | tourist | 184 |

2 | rng_58 | 170 |

3 | csacademy | 164 |

4 | Petr | 158 |

5 | Swistakk | 154 |

6 | lewin | 149 |

7 | Errichto | 146 |

7 | matthew99 | 146 |

9 | adamant | 141 |

10 | Zlobober | 140 |

Does Heavy Light Decomposition have any advantage over Binary Lifting Technique or using a sparse table? Can we solve some type of problem using HLD which can't be solved using the other mentioned techniques?

↑

↓

Codeforces (c) Copyright 2010-2018 Mike Mirzayanov

The only programming contests Web 2.0 platform

Server time: Feb/25/2018 18:37:46 (d2).

Desktop version, switch to mobile version.

User lists

Name |
---|

Hld is useful when u are given some kind of non-invertible operation queries with updates. For example, consider the problem witht the following 2 queries:

Update the value of node X to Y

Say the GCD of the path u...v

Can this be done in some other way ?

Ah ok, so it should be used when we need to support update queries. That didn't strike me for some reason. Thanks!

Apart from update queries, ofc:

HLD:

O(N) preprocessing,O(logN) LCA query,O(N) memory.Binary lifting:

O(NlogN) preprocessing,O(logN) LCA query,O(NlogN) memory.Sparse table on DFS order:

O(NlogN) preprocessing,O(1) LCA query,O(NlogN) memory.Segment tree on DFS order:

O(N) preprocessing,O(logN) LCA query,O(N) memory.It's easy to see that HLD beats binary lifting by any means (except for simplicity which is actually quite important in CP), sparse table has a better query time but worse preprocessing time and memory complexity while segment tree gives you the same complexities. Not sure if the constant factor for querying segment tree is bigger than the one for LCA query in HLD but I guess so.

`HLD: O(N) preprocessing, O(logN) LCA query, O(N) memory.`

What do you mean by LCA query? LCA can be calculated in O(logN) irrespective of HLD/sparse tables, right?

Maybe I have misunderstood what you meant but if you mean query a given path using HLD, that can take

O(logN*logN)time, because you may encounter at mostlogNlight edges and for each light edge you will perform a query on the segment tree representing the heavy path above it.What I mean by LCA query is find the LCA of two nodes. You can do it with HLD, simply bringing one of the nodes to the next chain, depending on which one is deeper until they happen to be in the same chain.