153 lines
5.1 KiB
Scheme
153 lines
5.1 KiB
Scheme
; Copyright (c) 1993-1999 by Richard Kelsey and Jonathan Rees. See file COPYING.
|
|
|
|
|
|
; Code to find the strongly connected components of a graph.
|
|
; (TO <vertex>) are the vertices that have an edge to <vertex>.
|
|
; (SLOT <vertex>) and (SET-SLOT! <vertex> <value>) is a settable slot
|
|
; used by the algorithm.
|
|
;
|
|
; The components are returned in a backwards topologically sorted list.
|
|
|
|
(define (strongly-connected-components vertices to slot set-slot!)
|
|
(make-vertices vertices to slot set-slot!)
|
|
(let loop ((to-do vertices) (index 0) (stack #t) (comps '()))
|
|
(let ((to-do (find-next-vertex to-do slot)))
|
|
(cond ((null? to-do)
|
|
(for-each (lambda (n) (set-slot! n #f)) vertices)
|
|
comps)
|
|
(else
|
|
(call-with-values
|
|
(lambda ()
|
|
(do-vertex (slot (car to-do)) index stack comps))
|
|
(lambda (index stack comps)
|
|
(loop to-do index stack comps))))))))
|
|
|
|
(define (find-next-vertex vertices slot)
|
|
(do ((vertices vertices (cdr vertices)))
|
|
((or (null? vertices)
|
|
(= 0 (vertex-index (slot (car vertices)))))
|
|
vertices)))
|
|
|
|
(define-record-type vertex :vertex
|
|
(really-make-vertex data edges stack index parent lowpoint)
|
|
vertex?
|
|
(data vertex-data) ; user's data
|
|
(edges vertex-edges set-vertex-edges!) ; list of vertices
|
|
(stack vertex-stack set-vertex-stack!) ; next vertex on the stack
|
|
(index vertex-index set-vertex-index!) ; time at which this vertex was
|
|
; reached in the traversal
|
|
(parent vertex-parent set-vertex-parent!) ; a vertex pointing to this one
|
|
(lowpoint vertex-lowpoint set-vertex-lowpoint!)) ; lowest index in this
|
|
; vertices strongly connected component
|
|
|
|
(define (make-vertex data)
|
|
(really-make-vertex data '() #f 0 #f #f))
|
|
|
|
(define (make-vertices vertices to slot set-slot!)
|
|
(let ((maybe-slot (lambda (n)
|
|
(let ((s (slot n)))
|
|
(if (vertex? s)
|
|
s
|
|
(error "graph edge points to non-vertex" n))))))
|
|
(for-each (lambda (n)
|
|
(set-slot! n (make-vertex n)))
|
|
vertices)
|
|
(for-each (lambda (n)
|
|
(set-vertex-edges! (slot n) (map maybe-slot (to n))))
|
|
vertices)
|
|
(values)))
|
|
|
|
; The numbers are the algorithm step numbers from page 65 of Graph Algorithms,
|
|
; Shimon Even, Computer Science Press, 1979.
|
|
|
|
; 2
|
|
|
|
(define (do-vertex vertex index stack comps)
|
|
(let ((index (+ index '1)))
|
|
(set-vertex-index! vertex index)
|
|
(set-vertex-lowpoint! vertex index)
|
|
(set-vertex-stack! vertex stack)
|
|
(get-strong vertex index vertex comps)))
|
|
|
|
; 3
|
|
|
|
(define (get-strong vertex index stack comps)
|
|
(if (null? (vertex-edges vertex))
|
|
(end-vertex vertex index stack comps)
|
|
(follow-edge vertex index stack comps)))
|
|
|
|
; 7
|
|
|
|
(define (end-vertex vertex index stack comps)
|
|
(call-with-values
|
|
(lambda ()
|
|
(if (= (vertex-index vertex) (vertex-lowpoint vertex))
|
|
(unwind-stack vertex stack comps)
|
|
(values stack comps)))
|
|
(lambda (stack comps)
|
|
(cond ((vertex-parent vertex)
|
|
=> (lambda (parent)
|
|
(if (> (vertex-lowpoint parent) (vertex-lowpoint vertex))
|
|
(set-vertex-lowpoint! parent (vertex-lowpoint vertex)))
|
|
(get-strong parent index stack comps)))
|
|
(else
|
|
(values index stack comps))))))
|
|
|
|
(define (unwind-stack vertex stack comps)
|
|
(let loop ((n stack) (c '()))
|
|
(let ((next (vertex-stack n))
|
|
(c (cons (vertex-data n) c)))
|
|
(set-vertex-stack! n #f)
|
|
(if (eq? n vertex)
|
|
(values next (cons c comps))
|
|
(loop next c)))))
|
|
|
|
; 4
|
|
|
|
(define (follow-edge vertex index stack comps)
|
|
(let* ((next (pop-vertex-edge! vertex))
|
|
(next-index (vertex-index next)))
|
|
(cond ((= next-index 0)
|
|
(set-vertex-parent! next vertex)
|
|
(do-vertex next index stack comps))
|
|
(else
|
|
(if (and (< next-index (vertex-index vertex))
|
|
(vertex-stack next)
|
|
(< next-index (vertex-lowpoint vertex)))
|
|
(set-vertex-lowpoint! vertex next-index))
|
|
(get-strong vertex index stack comps)))))
|
|
|
|
(define (pop-vertex-edge! vertex)
|
|
(let ((edges (vertex-edges vertex)))
|
|
(set-vertex-edges! vertex (cdr edges))
|
|
(car edges)))
|
|
|
|
; GRAPH is ((<symbol> . <symbol>*)*)
|
|
|
|
;(define (test-strong graph)
|
|
; (let ((vertices (map (lambda (n)
|
|
; (vector (car n) #f #f))
|
|
; graph)))
|
|
; (for-each (lambda (data vertex)
|
|
; (vector-set! vertex 1 (map (lambda (s)
|
|
; (first (lambda (v)
|
|
; (eq? s (vector-ref v 0)))
|
|
; vertices))
|
|
; (cdr data))))
|
|
; graph
|
|
; vertices)
|
|
; (map (lambda (l)
|
|
; (map (lambda (n) (vector-ref n 0)) l))
|
|
; (strongly-connected-components vertices
|
|
; (lambda (v) (vector-ref v 1))
|
|
; (lambda (v) (vector-ref v 2))
|
|
; (lambda (v val)
|
|
; (vector-set! v 2 val))))))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|