Kosaraju: Difference between revisions

<br>

Kosaraju's algorithm (also known as the Kosaraju–Sharir algorithm) is a linear time algorithm to find the strongly connected components of a directed graph. Aho, Hopcroft and Ullman credit it to an unpublished paper from 1978 by S. Rao Kosaraju. The same algorithm was independently discovered by Micha Sharir and published by him in 1981. It makes use of the fact that the transpose graph (the same graph with the direction of every edge reversed) has exactly the same strongly connected components as the original graph.

<br>

;References:

{{trans|Python}}

 

V size = g.len

V vis = [0B] * size

V t = [[Int]()] * size

 

I !@vis[u]

@vis[u] = 1B

V c = [0] * size

 

I @vis[u]

@vis[u] = 0B

 

V g = [[1], [2], [0], [1, 2, 4], [3, 5], [2, 6], [5], [4, 6, 7]]

 

{{out}}

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

 

Assign(u, u);

}

 

=={{header|C++}}==

{{trans|D}}

#include <iostream>

#include <ostream>

 

return 0;

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

=={{header|D}}==

{{trans|Kotlin}} (mostly) with output like {{trans|Go}}

import std.stdio;

 

void main() {

writeln(kosaraju(g));

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

 

=={{header|Go}}==

 

import "fmt"

}

return c

{{out}}

<pre>

[0 0 0 3 3 5 5 7]

</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

Output is like Go instead of what Kotlin outputs.

import java.util.Arrays;

import java.util.List;

System.out.println(output);

}

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

 

=={{header|Julia}}==

{{trans|Go}}

 

# 1. For each vertex u of the graph, mark u as unvisited. Let L be empty.

vis = falses(length(g))

 

g = [[2], [3], [1], [2, 3, 5], [4, 6], [3, 7], [6], [5, 7, 8]]

 

{{out}}

<pre>[1, 1, 1, 4, 4, 6, 6, 8]</pre>

 

=={{header|Kotlin}}==

{{trans|Go}}

 

/* the list index is the first vertex in the edge(s) */

fun main(args: Array<String>) {

println(kosaraju(g).joinToString("\n"))

 

{{out}}

=={{header|Lua}}==

{{trans|C++}}

io.write("[")

for i=0,#a do

 

write_array(kosaraju(g))

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

kosaraju(%test1);

say '';

{{out}}

<pre>0 1 2

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Python}}==

class nonlocal: pass

 

 

g = [[1], [2], [0], [1,2,4], [3,5], [2,6], [5], [4,6,7]]

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

 

=={{header|Racket}}==

 

(require racket/dict)

(3 1 2 4) ; equvalent to (3 . (1 2 4))

(4 5 3)

 

{{out}}

Accepts a hash of lists/arrays holding the vertex (name => (neighbors)) pairs. No longer limited to continuous, positive, integer vertex names.

 

my %g = %k.keys.sort Z=> flat ^%k;

my %h = %g.invert;

:Gary<Fred>,

:Hank<Earl Gary Hank>)

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Julia}}

# 1. For each vertex u of the graph, mark u as unvisited. Let L be empty.

var vis = g.len.of(false)

 

var g = [[1], [2], [0], [1, 2, 4], [3, 5], [2, 6], [5], [4, 6, 7]]

{{out}}

<pre>

 

=={{header|Standard ML}}==

 

fun node x = Node (x, ref false, ref nil, ref nil)

 

val ns = make (16, is, ijs)

{{out}}

<pre>

{{trans|D}}

 

let size = graph.count

var x = size

]

 

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|Java}}

 

Function Kosaraju(g As List(Of List(Of Integer))) As List(Of Integer)

End Sub

 

{{out}}

<pre>[0, 0, 0, 3, 3, 5, 5, 7]</pre>

=={{header|Wren}}==

{{trans|Go}}

var gc = g.count

// 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.

 

var g = [ [1], [2], [0], [1, 2, 4], [3, 5], [2, 6], [5], [4, 6, 7] ]

 

{{out}}

 

=={{header|zkl}}==

 

fcn visit(u,G,L){ // u is ((visited,assigned), (id,edges))

 

return(components);

// with vertices id zero based (vs 1 based in article)

// ids start at zero and are consecutive (no holes), graph is unsorted

T( T(0,1), T(2,0), T(5,2,6), T(6,5),

T(1,2), T(3,1,2,4), T(4,5,3), T(7,4,7,6) );

{{out}}

<pre>