推移簡約アルゴリズム：擬似コード？
グラフで推移簡約を実行するアルゴリズムを探していましたが、成功しませんでした。私のアルゴリズムのバイブル（Cormen et alによるAlgorithmsの紹介）には何もありません。推移閉包の擬似コードをたくさん見ましたが、削減のために何も追跡することができませんでした。私が持っている最も近いものは、Volker Turau（ISBN：978-3-486-59057-9）の「AlgorithmischeGraphentheorie」にあるものですが、残念ながら私はこの本にアクセスできません！ウィキペディアは役に立たず、グーグルはまだ何も発表していません。 ：^（
推移簡約を実行するためのアルゴリズムを知っている人はいますか？
ハリー・スーを参照してください。 「有向グラフの最小等価グラフを見つけるためのアルゴリズム。」、Journal of the ACM、22（1）：11-16、1975年1月。DAGには以下の単純な3次アルゴリズム（N x Nパス行列を使用）で十分です。しかし、スーはそれを循環グラフに一般化します。
// reflexive reduction
for (int i = 0; i < N; ++i)
m[i][i] = false;
// transitive reduction
for (int j = 0; j < N; ++j)
for (int i = 0; i < N; ++i)
if (m[i][j])
for (int k = 0; k < N; ++k)
if (m[j][k])
m[i][k] = false;
私が使用した推移簡約アルゴリズムの基本的な要点は
foreach x in graph.vertices
foreach y in graph.vertices
foreach z in graph.vertices
delete Edge xz if edges xy and yz exist
同じスクリプトで使用した推移閉包アルゴリズムは非常に似ていますが、最後の行は
add Edge xz if edges xy and yz OR Edge xz exist
隣接行列（エッジがある場合にのみ1を持つ）の代わりに、パス行列（ノードiからノードjへのパスがある場合は1を持つ）を使用する必要があるというAlanDonovanによって提供された参照に基づくノードiからノードjへ）。
いくつかのサンプルpythonコードは、ソリューション間の違いを示すために以下に続きます
def prima(m, title=None):
""" Prints a matrix to the terminal """
if title:
print title
for row in m:
print ', '.join([str(x) for x in row])
print ''
def path(m):
""" Returns a path matrix """
p = [list(row) for row in m]
n = len(p)
for i in xrange(0, n):
for j in xrange(0, n):
if i == j:
continue
if p[j][i]:
for k in xrange(0, n):
if p[j][k] == 0:
p[j][k] = p[i][k]
return p
def hsu(m):
""" Transforms a given directed acyclic graph into its minimal equivalent """
n = len(m)
for j in xrange(n):
for i in xrange(n):
if m[i][j]:
for k in xrange(n):
if m[j][k]:
m[i][k] = 0
m = [ [0, 1, 1, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1],
[0, 1, 0, 0, 0]]
prima(m, 'Original matrix')
hsu(m)
prima(m, 'After Hsu')
p = path(m)
prima(p, 'Path matrix')
hsu(p)
prima(p, 'After Hsu')
出力：
Adjacency matrix
0, 1, 1, 0, 0
0, 0, 0, 0, 0
0, 0, 0, 1, 1
0, 0, 0, 0, 1
0, 1, 0, 0, 0
After Hsu
0, 1, 1, 0, 0
0, 0, 0, 0, 0
0, 0, 0, 1, 0
0, 0, 0, 0, 1
0, 1, 0, 0, 0
Path matrix
0, 1, 1, 1, 1
0, 0, 0, 0, 0
0, 1, 0, 1, 1
0, 1, 0, 0, 1
0, 1, 0, 0, 0
After Hsu
0, 0, 1, 0, 0
0, 0, 0, 0, 0
0, 0, 0, 1, 0
0, 0, 0, 0, 1
0, 1, 0, 0, 0
ウィキペディアの記事 推移簡約は、GraphViz（オープンソース）内の実装を示しています。正確には擬似コードではありませんが、どこかで始めるべきでしょうか？
LEDAには 推移簡約アルゴリズム が含まれています。 LEDA book のコピーはもうありません。この関数は、本の発行後に追加された可能性があります。しかし、それがそこにある場合は、アルゴリズムの適切な説明があります。
グーグルは アルゴリズム 誰かがブーストに含めることを提案したことを指摘している。私はそれを読もうとしなかったので、多分正しくないのですか？
また、 this は一見の価値があるかもしれません。
「girlwithglasses」のアルゴリズムは、冗長なエッジが3つのエッジのチェーンにまたがることを忘れています。修正するには、Q = R x R +を計算します。ここで、R +は推移閉包であり、Qに表示されるRからすべてのエッジを削除します。ウィキペディアの記事も参照してください。
疑似Pythonの深さ優先アルゴリズム：
for vertex0 in vertices:
done = set()
for child in vertex0.children:
df(edges, vertex0, child, done)
df = function(edges, vertex0, child0, done)
if child0 in done:
return
for child in child0.children:
Edge.discard((vertex0, child))
df(edges, vertex0, child, done)
done.add(child0)
アルゴリズムは最適ではありませんが、以前のソリューションのマルチエッジスパン問題を処理します。結果は、graphvizからのtredが生成するものと非常によく似ています。
Java/jgrapht、python @Michael Clerxからのこのページのサンプル：
import Java.util.ArrayList;
import Java.util.List;
import Java.util.Set;
import org.jgrapht.DirectedGraph;
public class TransitiveReduction<V, E> {
final private List<V> vertices;
final private int [][] pathMatrix;
private final DirectedGraph<V, E> graph;
public TransitiveReduction(DirectedGraph<V, E> graph) {
super();
this.graph = graph;
this.vertices = new ArrayList<V>(graph.vertexSet());
int n = vertices.size();
int[][] original = new int[n][n];
// initialize matrix with zeros
// --> 0 is the default value for int arrays
// initialize matrix with edges
Set<E> edges = graph.edgeSet();
for (E Edge : edges) {
V v1 = graph.getEdgeSource(Edge);
V v2 = graph.getEdgeTarget(Edge);
int v_1 = vertices.indexOf(v1);
int v_2 = vertices.indexOf(v2);
original[v_1][v_2] = 1;
}
this.pathMatrix = original;
transformToPathMatrix(this.pathMatrix);
}
// (package visible for unit testing)
static void transformToPathMatrix(int[][] matrix) {
// compute path matrix
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix.length; j++) {
if (i == j) {
continue;
}
if (matrix[j][i] > 0 ){
for (int k = 0; k < matrix.length; k++) {
if (matrix[j][k] == 0) {
matrix[j][k] = matrix[i][k];
}
}
}
}
}
}
// (package visible for unit testing)
static void transitiveReduction(int[][] pathMatrix) {
// transitively reduce
for (int j = 0; j < pathMatrix.length; j++) {
for (int i = 0; i < pathMatrix.length; i++) {
if (pathMatrix[i][j] > 0){
for (int k = 0; k < pathMatrix.length; k++) {
if (pathMatrix[j][k] > 0) {
pathMatrix[i][k] = 0;
}
}
}
}
}
}
public void reduce() {
int n = pathMatrix.length;
int[][] transitivelyReducedMatrix = new int[n][n];
System.arraycopy(pathMatrix, 0, transitivelyReducedMatrix, 0, pathMatrix.length);
transitiveReduction(transitivelyReducedMatrix);
for (int i = 0; i <n; i++) {
for (int j = 0; j < n; j++) {
if (transitivelyReducedMatrix[i][j] == 0) {
// System.out.println("removing "+vertices.get(i)+" -> "+vertices.get(j));
graph.removeEdge(graph.getEdge(vertices.get(i), vertices.get(j)));
}
}
}
}
}
単体テスト ：
import Java.util.Arrays;
import org.junit.Assert;
import org.junit.Test;
public class TransitiveReductionTest {
@Test
public void test() {
int[][] matrix = new int[][] {
{0, 1, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 1},
{0, 0, 0, 0, 1},
{0, 1, 0, 0, 0}
};
int[][] expected_path_matrix = new int[][] {
{0, 1, 1, 1, 1},
{0, 0, 0, 0, 0},
{0, 1, 0, 1, 1},
{0, 1, 0, 0, 1},
{0, 1, 0, 0, 0}
};
int[][] expected_transitively_reduced_matrix = new int[][] {
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 1, 0},
{0, 0, 0, 0, 1},
{0, 1, 0, 0, 0}
};
System.out.println(Arrays.deepToString(matrix) + " original matrix");
int n = matrix.length;
// calc path matrix
int[][] path_matrix = new int[n][n];
{
System.arraycopy(matrix, 0, path_matrix, 0, matrix.length);
TransitiveReduction.transformToPathMatrix(path_matrix);
System.out.println(Arrays.deepToString(path_matrix) + " path matrix");
Assert.assertArrayEquals(expected_path_matrix, path_matrix);
}
// calc transitive reduction
{
int[][] transitively_reduced_matrix = new int[n][n];
System.arraycopy(path_matrix, 0, transitively_reduced_matrix, 0, matrix.length);
TransitiveReduction.transitiveReduction(transitively_reduced_matrix);
System.out.println(Arrays.deepToString(transitively_reduced_matrix) + " transitive reduction");
Assert.assertArrayEquals(expected_transitively_reduced_matrix, transitively_reduced_matrix);
}
}
}
テスト出力
[[0, 1, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 1, 0, 0, 0]] original matrix
[[0, 1, 1, 1, 1], [0, 0, 0, 0, 0], [0, 1, 0, 1, 1], [0, 1, 0, 0, 1], [0, 1, 0, 0, 0]] path matrix
[[0, 0, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 1, 0, 0, 0]] transitive reduction