Add gomory-hu article #1308

igbrade · 2024-07-09T20:57:26Z

No description provided.

github-actions · 2024-07-11T13:40:20Z

Visit the preview URL for this PR (for commit c278efa):

https://cp-algorithms--preview-1308-w9guphnj.web.app

(expires 2024-07-18T13:40:14.892553068Z)

adamant-pwn

Hi, thanks for the suggestion! Could you please address the comments in the review?

adamant-pwn · 2024-07-11T13:43:31Z

src/graph/gomory_hu.md

+
+## Definition
+
+The gomory-hu tree of an undirected graph $G$ with capacities consists of a weighted tree that condenses information from all the *s-t cuts* for all s-t vertex pairs in the graph. Naively, one must think that $O(|V|^2)$ flow computations are needed to build this data structure, but actually it can be shown that only $|V| - 1$ flow computations are needed. Once the tree is constructed, we can get the minimum cut between two vertices *s* and *t* by querying the minimum weight edge in the unique *s-t* path.


Suggested change

The gomory-hu tree of an undirected graph $G$ with capacities consists of a weighted tree that condenses information from all the *s-t cuts* for all s-t vertex pairs in the graph. Naively, one must think that $O(|V|^2)$ flow computations are needed to build this data structure, but actually it can be shown that only $|V| - 1$ flow computations are needed. Once the tree is constructed, we can get the minimum cut between two vertices *s* and *t* by querying the minimum weight edge in the unique *s-t* path.

The Gomory–Hu tree of an undirected graph $G$ with capacities is a weighted tree such that for any pair of vertices $s$ and $t$, the weight of the minimum edge on the path between $s$ and $t$ is equal to the value of the minimum cut between $s$ and $t$. It can be shown that only $|V| - 1$ flow computations are needed to construct the tree, which is an improvement over the naive $O(|V|^2)$ algorithm of finding maximum flow between each pair of vertices.

Generally, it would be nice to explain why this tree is well-defined (e.g. why it always exists), if possible.

adamant-pwn · 2024-07-11T14:07:22Z

src/graph/gomory_hu.md

+We can say that two cuts $(X, Y)$ and $(U, V)$ *cross* if all four set intersections $X \cap U$, $X \cap V$, $Y \cap U$, $Y \cap V$ are nonempty. Most of the work of the original gomory-hu method is involved in maintaining the noncrossing condition. The following simpler, yet efficient method, proposed by Gusfield uses crossing cuts to produce equivalent flow trees.
+
+Lets assume the vertices are 0-indexed for the next section
+The algorithm is composed of the following steps:
+
+1. Create a (star) tree $T'$ on $n$ nodes, with node 0 at the center and nodes 1 through $n - 1$ at the leaves.
+2. For $i$ from 1 to $n - 1$ do steps 3 and 4
+3. Compute the minimum cut $(X, Y)$ in $G$ between (leaf) node $i$ and its (unique) neighbor $t$ in $T'$. Label the edge $(i, t)$ in $T'$ with the capacity of the $(X, Y)$ cut.
+4. For every node $j$ larger than $i$, if $j$ is a neighbor of $t$ and $j$ is on the $i$ side of $(X, Y)$, then modify $T'$ by disconnecting $j$ from $t$ and connecting $j$ to $i$. Note that each node $j$ larger than $i$ remains a leaf in $T'$
+
+It is easy to see that at every iteration, node $i$ and all nodes larger than $i$ are leaves in $T'$, as required by the algorithm.


The way it is written now, it's very hard to see why the algorithm works this way. For example, crossing cuts are defined, but it is not explained why it is a property of interest that can be useful and helpful. It's not even clear how (non-)crossing curs are connected with the algorithm itself.

I assume the algorithm strives to maintain some kind of invariant that intermediate states provide a correct upper bound on the cut between any pair of vertices, and the bound is tight when the vertex is "finalised", but I don't see any natural explanation to why it's actually true?

adamant-pwn · 2024-07-11T14:09:11Z

src/graph/gomory_hu.md

+
+## Complexity
+
+The algorithm total complexity is $\mathcal{O}(V*MaxFlow)$, wich means that the overall complexity depends on the algorithm that was choosen to find the maximum flow.


Suggested change

The algorithm total complexity is $\mathcal{O}(V*MaxFlow)$, wich means that the overall complexity depends on the algorithm that was choosen to find the maximum flow.

The algorithm total complexity is $\mathcal{O}(V)$ times the complexity of a single maximum flow call, wich means that the overall complexity depends on the algorithm that was chosen to find the maximum flow.

adamant-pwn · 2024-07-11T14:09:36Z

src/graph/gomory_hu.md

+The algorithm total complexity is $\mathcal{O}(V*MaxFlow)$, wich means that the overall complexity depends on the algorithm that was choosen to find the maximum flow.
+
+### Implementation
+This implementation considers the Gomory-Hu tree as a struct with methods:


Suggested change

This implementation considers the Gomory-Hu tree as a struct with methods:

Below, we implement the Gomory-Hu tree as a `struct` with methods:

adamant-pwn · 2024-07-11T14:11:05Z

src/graph/gomory_hu.md

+
+- The method *solve* returns a list that contains for each index $i$ the cost of the edge connecting $i$ and its parent, and the parent number.
+
+- Note that the algorithm doesn't produce a *cut tree*, only an *equivalent flow tree*, so one cannot retrieve the two components of a cut from the tree $T'$.


What is a cut tree? What is an equivalent flow tree? Neither are properly defined...

adamant-pwn · 2024-07-11T14:11:58Z

src/graph/gomory_hu.md

+
+- Note that the algorithm doesn't produce a *cut tree*, only an *equivalent flow tree*, so one cannot retrieve the two components of a cut from the tree $T'$.
+
+```{.cpp file=gomoryhu}


Was this implementation tested on any problem? If possible, it'd be nice to add some tests to the implementation, see here.

adamant-pwn · 2024-07-11T14:12:39Z

src/graph/gomory_hu.md

@@ -0,0 +1,100 @@
+# Gomory Hu Tree


Suggested change

# Gomory Hu Tree

---

tags:

- Original

---

# Gomory-Hu Tree

adamant-pwn · 2024-07-11T14:13:36Z

src/navigation.md

@@ -189,6 +189,7 @@ search:
        - [Flows with demands](graph/flow_with_demands.md)
        - [Minimum-cost flow](graph/min_cost_flow.md)
        - [Assignment problem](graph/Assignment-problem-min-flow.md)
+        - [All-pairs minimum cut - Gomory Hu](graph/gomory_hu.md)


Suggested change

- [All-pairs minimum cut - Gomory Hu](graph/gomory_hu.md)

- [Gomory-Hu tree](graph/gomory_hu.md)

Please also add it to the list of new articles in README.

feat: add gomory-hu implementation and description

20dc3ca

igbrade force-pushed the master branch from aeea4c3 to 20dc3ca Compare July 9, 2024 21:00

fix(gomory-hu): typos and improve style

a40adf7

igbrade marked this pull request as ready for review July 10, 2024 01:25

feat(gomory-hu): add step-by-step description of the algorithm

c278efa

igbrade force-pushed the master branch from 4ddf095 to c278efa Compare July 10, 2024 01:27

adamant-pwn requested changes Jul 11, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add gomory-hu article #1308

Add gomory-hu article #1308

igbrade commented Jul 9, 2024

github-actions bot commented Jul 11, 2024

adamant-pwn left a comment

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024

adamant-pwn Jul 11, 2024


		## Definition

		The gomory-hu tree of an undirected graph $G$ with capacities consists of a weighted tree that condenses information from all the s-t cuts for all s-t vertex pairs in the graph. Naively, one must think that $O(\|V\|^2)$ flow computations are needed to build this data structure, but actually it can be shown that only $\|V\| - 1$ flow computations are needed. Once the tree is constructed, we can get the minimum cut between two vertices s and t by querying the minimum weight edge in the unique s-t path.


		## Complexity

		The algorithm total complexity is $\mathcal{O}(V*MaxFlow)$, wich means that the overall complexity depends on the algorithm that was choosen to find the maximum flow.

	This implementation considers the Gomory-Hu tree as a struct with methods:
	Below, we implement the Gomory-Hu tree as a `struct` with methods:


		- The method solve returns a list that contains for each index $i$ the cost of the edge connecting $i$ and its parent, and the parent number.

		- Note that the algorithm doesn't produce a cut tree, only an equivalent flow tree, so one cannot retrieve the two components of a cut from the tree $T'$.


		- Note that the algorithm doesn't produce a cut tree, only an equivalent flow tree, so one cannot retrieve the two components of a cut from the tree $T'$.

		```{.cpp file=gomoryhu}

-# Gomory Hu Tree
+---
+tags:
+    - Original
+---
+# Gomory-Hu Tree

	- [All-pairs minimum cut - Gomory Hu](graph/gomory_hu.md)
	- [Gomory-Hu tree](graph/gomory_hu.md)

Add gomory-hu article #1308

Are you sure you want to change the base?

Add gomory-hu article #1308

Conversation

igbrade commented Jul 9, 2024

github-actions bot commented Jul 11, 2024

adamant-pwn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment