Skip to main content
`Ctrl`+`K`

# Approximations and Heuristics

Approximations of graph properties and Heuristic methods for optimization.

The functions in this class are not imported into the top-level `networkx` namespace so the easiest way to use them is with:

    >>> from networkx.algorithms import approximation

Another option is to import the specific function with `from networkx.algorithms.approximation import function_name`.

## Connectivity

Fast approximation for node connectivity

`all_pairs_node_connectivity`(G[, nbunch, cutoff]) | Compute node connectivity between all pairs of nodes.
`local_node_connectivity`(G, source, target[, ...]) | Compute node connectivity between source and target.
`node_connectivity`(G[, s, t]) | Returns an approximation for node connectivity for a graph or digraph G.

## K-components

Fast approximation for k-component structure

`k_components`(G[, min_density]) | Returns the approximate k-component structure of a graph G.

## Clique

Functions for computing large cliques and maximum independent sets.

`maximum_independent_set`(G) | Returns an approximate maximum independent set.
`max_clique`(G) | Find the Maximum Clique
`clique_removal`(G) | Repeatedly remove cliques from the graph.
`large_clique_size`(G) | Find the size of a large clique in a graph.

## Clustering

`average_clustering`(G[, trials, seed]) | Estimates the average clustering coefficient of G.

## Distance Measures

Distance measures approximated metrics.

`diameter`(G[, seed]) | Returns a lower bound on the diameter of the graph G.

## Dominating Set

Functions for finding node and edge dominating sets.

A dominating set for an undirected graph G with vertex set V and edge set E is a subset D of V such that every vertex not in D is adjacent to at least one member of D. An edge dominating set is a subset F of E such that every edge not in F is incident to an endpoint of at least one edge in F.

`min_weighted_dominating_set`(G[, weight]) | Returns a dominating set that approximates the minimum weight node dominating set.
`min_edge_dominating_set`(G) | Returns minimum cardinality edge dominating set.

## Matching

Given a graph G = (V,E), a matching M in G is a set of pairwise non-adjacent edges; that is, no two edges share a common vertex.

Wikipedia: Matching

`min_maximal_matching`(G) | Returns the minimum maximal matching of G.

## Ramsey

Ramsey numbers.

`ramsey_R2`(G) | Compute the largest clique and largest independent set in `G`.

## Steiner Tree

`metric_closure`(G[, weight]) | Return the metric closure of a graph.
`steiner_tree`(G, terminal_nodes[, weight, method]) | Return an approximation to the minimum Steiner tree of a graph.

## Traveling Salesman

### Travelling Salesman Problem (TSP)

Implementation of approximate algorithms for solving and approximating the TSP problem.

Categories of algorithms which are implemented:

- Christofides (provides a 3/2-approximation of TSP)

- Greedy

- Simulated Annealing (SA)

- Threshold Accepting (TA)

- Asadpour Asymmetric Traveling Salesman Algorithm

The Travelling Salesman Problem tries to find, given the weight (distance) between all points where a salesman has to visit, the route so that:

- The total distance (cost) which the salesman travels is minimized.

- The salesman returns to the starting point.

- Note that for a complete graph, the salesman visits each point once.

The function `travelling_salesman_problem` allows for incomplete graphs by finding all-pairs shortest paths, effectively converting the problem to a complete graph problem. It calls one of the approximate methods on that problem and then converts the result back to the original graph using the previously found shortest paths.

TSP is an NP-hard problem in combinatorial optimization, important in operations research and theoretical computer science.

http://en.wikipedia.org/wiki/Travelling_salesman_problem

`christofides`(G[, weight, tree]) | Approximate a solution of the traveling salesman problem
`traveling_salesman_problem`(G[, weight, ...]) | Find the shortest path in `G` connecting specified nodes
`greedy_tsp`(G[, weight, source]) | Return a low cost cycle starting at `source` and its cost.
`simulated_annealing_tsp`(G, init_cycle[, ...]) | Returns an approximate solution to the traveling salesman problem.
`threshold_accepting_tsp`(G, init_cycle[, ...]) | Returns an approximate solution to the traveling salesman problem.
`asadpour_atsp`(G[, weight, seed, source]) | Returns an approximate solution to the traveling salesman problem.

## Treewidth

Functions for computing treewidth decomposition.

Treewidth of an undirected graph is a number associated with the graph. It can be defined as the size of the largest vertex set (bag) in a tree decomposition of the graph minus one.

Wikipedia: Treewidth

The notions of treewidth and tree decomposition have gained their attractiveness partly because many graph and network problems that are intractable (e.g., NP-hard) on arbitrary graphs become efficiently solvable (e.g., with a linear time algorithm) when the treewidth of the input graphs is bounded by a constant [1] [2].

There are two different functions for computing a tree decomposition: `treewidth_min_degree()` and `treewidth_min_fill_in()`.

[1]

Hans L. Bodlaender and Arie M. C. A. Koster. 2010. “Treewidth computations I.Upper bounds”. Inf. Comput. 208, 3 (March 2010),259-275. http://dx.doi.org/10.1016/j.ic.2009.03.008

[2]

Hans L. Bodlaender. “Discovering Treewidth”. Institute of Information and Computing Sciences, Utrecht University. Technical Report UU-CS-2005-018. http://www.cs.uu.nl

[3]

K. Wang, Z. Lu, and J. Hicks Treewidth. https://web.archive.org/web/20210507025929/http://web.eecs.utk.edu/~cphill25/cs594_spring2015_projects/treewidth.pdf

`treewidth_min_degree`(G) | Returns a treewidth decomposition using the Minimum Degree heuristic.
`treewidth_min_fill_in`(G) | Returns a treewidth decomposition using the Minimum Fill-in heuristic.

## Vertex Cover

Functions for computing an approximate minimum weight vertex cover.

A vertex cover is a subset of nodes such that each edge in the graph is incident to at least one node in the subset.

`min_weighted_vertex_cover`(G[, weight]) | Returns an approximate minimum weighted vertex cover.

## Max Cut

`randomized_partitioning`(G[, seed, p, weight]) | Compute a random partitioning of the graph nodes and its cut value.
`one_exchange`(G[, initial_cut, seed, weight]) | Compute a partitioning of the graphs nodes and the corresponding cut value.