# Reconstructing edge-disjoint paths, a tighter analysis

This is a small improvement of the analysis of [1], this assume you already read that paper.

###### 0.0.0.0.0.1

Given a simple undirected graph of $n$ vertices and $m$ edges, construct a data structure such that we can query two vertices $u$ and $v$, and it returns the maximum edge disjoint paths between $u$ and $v$.

We let $MF(n,m)$ to be the time to compute $st$-maximum flow on a undirected unit capacity graph.

The current state of art in the article is:

- Proprocessing time $O(nMF(n,m))$.
- $O(n^3)$ space.
- $O(\alpha(n)\lambda(u,v)n)$ query time.

We can improve this by having a tighter analysis.

First, if $f$ and $g$ be $k$-edge disjoint path from $x$ to $y$ and $y$ to $z$ respectively. Let $m$ be the number of edges in $f\cup g$, then there exist an algorithm to output $k$-edge disjoint path from $x$ to $z$ in $O(m)$ time. One can see this by update section $2$ of their paper by using a stable matching algorithm without the dummy edges, because this is just stable matching with incomplete lists[2].

Second, acyclic flow of value $f$ uses only $O(\sqrt{f}n)$ edges(Theorem 3.1 in [3]), therefore we do not have to store any non-acyclic flows. This also speed up all computations because the number of edges are smaller.

Third, we can use $O(n^{2.5}\log n)$ space and get a query time of $O(\sqrt{\lambda(u,v)}n)$. In fact there is a time space trade off [4].

Thus finally, we get

- Proprocessing time $O(nMF(n,m))$.
- $O(n^{2.5}\log n)$ space.
- $O(\sqrt{\lambda(u,v)}n)$ query time.

With even better analysis, we can obtain the following [5].

- Proprocessing time $O(nMF(n,m))$.
- $O(\sqrt{m}n^{3/2}\log n)$ space.
- $O(\sqrt{k}n)$ query time for a $k$ edge disjoint path from $u$ to $v$.

# References

[1] M. Conforti, R. Hassin, R. Ravi, **Reconstructing edge-disjoint paths**, Operations Research Letters. 31 (2003) 273–276 10.1016/S0167-6377(03)00022-1.

[2] K. Iwama, S. Miyazaki, Y. Morita, D. Manlove, Stable marriage with incomplete lists and ties, in: J. Wiedermann, P. van Emde Boas, M. Nielsen (Eds.), Automata, Languages and Programming, Springer Berlin Heidelberg, 1999: pp. 443–452 10.1007/3-540-48523-6_41.

[3] D.R. Karger, M.S. Levine, **Finding maximum flows in undirected graphs seems easier than bipartite matching**, Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing - STOC ’98. (1998) 69–78 10.1145/276698.276714.

[4] N. Alon, B. Schieber, **Optimal preprocessing for answering on-line product queries**, Tel Aviv University, 1987.

[5] C. Xu, **Reconstructing edge-disjoint paths faster**, Operations Research Letters. 44 (2016) 174–176 https://doi.org/10.1016/j.orl.2015.12.017.