146 lignes
4.7 KiB
PHP
146 lignes
4.7 KiB
PHP
<?php
|
|
|
|
/**
|
|
* @file
|
|
* Directed acyclic graph manipulation.
|
|
*/
|
|
|
|
|
|
/**
|
|
* Performs a depth-first search and sort on a directed acyclic graph.
|
|
*
|
|
* @param $graph
|
|
* A three dimensional associated array, with the first keys being the names
|
|
* of the vertices, these can be strings or numbers. The second key is
|
|
* 'edges' and the third one are again vertices, each such key representing
|
|
* an edge. Values of array elements are copied over.
|
|
*
|
|
* Example:
|
|
* @code
|
|
* $graph[1]['edges'][2] = 1;
|
|
* $graph[2]['edges'][3] = 1;
|
|
* $graph[2]['edges'][4] = 1;
|
|
* $graph[3]['edges'][4] = 1;
|
|
* @endcode
|
|
*
|
|
* On return you will also have:
|
|
* @code
|
|
* $graph[1]['paths'][2] = 1;
|
|
* $graph[1]['paths'][3] = 1;
|
|
* $graph[2]['reverse_paths'][1] = 1;
|
|
* $graph[3]['reverse_paths'][1] = 1;
|
|
* @endcode
|
|
*
|
|
* @return
|
|
* The passed-in $graph with more secondary keys filled in:
|
|
* - 'paths': Contains a list of vertices than can be reached on a path from
|
|
* this vertex.
|
|
* - 'reverse_paths': Contains a list of vertices that has a path from them
|
|
* to this vertex.
|
|
* - 'weight': If there is a path from a vertex to another then the weight of
|
|
* the latter is higher.
|
|
* - 'component': Vertices in the same component have the same component
|
|
* identifier.
|
|
*
|
|
* @see _drupal_depth_first_search()
|
|
*/
|
|
function drupal_depth_first_search(&$graph) {
|
|
$state = array(
|
|
// The order of last visit of the depth first search. This is the reverse
|
|
// of the topological order if the graph is acyclic.
|
|
'last_visit_order' => array(),
|
|
// The components of the graph.
|
|
'components' => array(),
|
|
);
|
|
// Perform the actual search.
|
|
foreach ($graph as $start => $data) {
|
|
_drupal_depth_first_search($graph, $state, $start);
|
|
}
|
|
|
|
// We do such a numbering that every component starts with 0. This is useful
|
|
// for module installs as we can install every 0 weighted module in one
|
|
// request, and then every 1 weighted etc.
|
|
$component_weights = array();
|
|
|
|
foreach ($state['last_visit_order'] as $vertex) {
|
|
$component = $graph[$vertex]['component'];
|
|
if (!isset($component_weights[$component])) {
|
|
$component_weights[$component] = 0;
|
|
}
|
|
$graph[$vertex]['weight'] = $component_weights[$component]--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Performs a depth-first search on a graph.
|
|
*
|
|
* @param $graph
|
|
* A three dimensional associated graph array.
|
|
* @param $state
|
|
* An associative array. The key 'last_visit_order' stores a list of the
|
|
* vertices visited. The key components stores list of vertices belonging
|
|
* to the same the component.
|
|
* @param $start
|
|
* An arbitrary vertex where we started traversing the graph.
|
|
* @param $component
|
|
* The component of the last vertex.
|
|
*
|
|
* @see drupal_depth_first_search()
|
|
*/
|
|
function _drupal_depth_first_search(&$graph, &$state, $start, &$component = NULL) {
|
|
// Assign new component for each new vertex, i.e. when not called recursively.
|
|
if (!isset($component)) {
|
|
$component = $start;
|
|
}
|
|
// Nothing to do, if we already visited this vertex.
|
|
if (isset($graph[$start]['paths'])) {
|
|
return;
|
|
}
|
|
// Mark $start as visited.
|
|
$graph[$start]['paths'] = array();
|
|
|
|
// Assign $start to the current component.
|
|
$graph[$start]['component'] = $component;
|
|
$state['components'][$component][] = $start;
|
|
|
|
// Visit edges of $start.
|
|
if (isset($graph[$start]['edges'])) {
|
|
foreach ($graph[$start]['edges'] as $end => $v) {
|
|
// Mark that $start can reach $end.
|
|
$graph[$start]['paths'][$end] = $v;
|
|
|
|
if (isset($graph[$end]['component']) && $component != $graph[$end]['component']) {
|
|
// This vertex already has a component, use that from now on and
|
|
// reassign all the previously explored vertices.
|
|
$new_component = $graph[$end]['component'];
|
|
foreach ($state['components'][$component] as $vertex) {
|
|
$graph[$vertex]['component'] = $new_component;
|
|
$state['components'][$new_component][] = $vertex;
|
|
}
|
|
unset($state['components'][$component]);
|
|
$component = $new_component;
|
|
}
|
|
// Only visit existing vertices.
|
|
if (isset($graph[$end])) {
|
|
// Visit the connected vertex.
|
|
_drupal_depth_first_search($graph, $state, $end, $component);
|
|
|
|
// All vertices reachable by $end are also reachable by $start.
|
|
$graph[$start]['paths'] += $graph[$end]['paths'];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now that any other subgraph has been explored, add $start to all reverse
|
|
// paths.
|
|
foreach ($graph[$start]['paths'] as $end => $v) {
|
|
if (isset($graph[$end])) {
|
|
$graph[$end]['reverse_paths'][$start] = $v;
|
|
}
|
|
}
|
|
|
|
// Record the order of the last visit. This is the reverse of the
|
|
// topological order if the graph is acyclic.
|
|
$state['last_visit_order'][] = $start;
|
|
}
|