output from partition clown

Author: make-github-pseudonymous-again

src/maxback.js

@@ -0,0 +1,22 @@
+import { head } from '@aureooms/js-itertools' ;
+
+export default function _contract ( G, ordering ) {
+
+	const x = ordering[ordering.length-2];
+	const y = ordering[ordering.length-1];
+
+	const H = new Map();
+
+	for ( const u of head( ordering , -2 ) ) {
+		const n = [];
+		H.set(u, n);
+		for ( const v of G.get(u) ) n.push(v === y ? x : v);
+	}
+
+	const nx = [];
+	H.set(x,nx);
+	for ( const v of G.get(x) ) if ( v !== y ) nx.push(v);
+	for ( const v of G.get(y) ) if ( v !== x && v !== y ) nx.push(v);
+	return H;
+
+}

src/maxback/_contract.js

@@ -0,0 +1,31 @@
+import { attr , decreasing } from '@aureooms/js-compare' ;
+import { PairingHeap } from '@aureooms/js-pairing-heap' ;
+
+export default function* _order ( G ) {
+
+	const heap = new PairingHeap( attr( decreasing , 'key' ) );
+	const refs = new Map();
+
+	for ( const v of G.keys() ) refs.set(v, heap.push({ key : 0 , value : v })) ;
+
+	for ( const _ of G ) {
+
+		const max = heap.pop() ;
+		const u = max.value ;
+		yield [ u , max.key ] ;
+		refs.delete(u);
+
+		// update keys
+		for ( const v of G.get(u) ) {
+			if (!refs.has(v)) continue;
+			const ref = refs.get(v);
+			// max heap so decrease-key is used for +
+			heap.decreasekey(ref, {
+				key : ref.value.key + 1 ,
+				value : ref.value.value
+			} );
+		}
+
+	}
+
+}

src/maxback/_order.js

@@ -0,0 +1,29 @@
+import { list , map , head , filter , chain } from '@aureooms/js-itertools' ;
+
+import _order from './_order' ;
+import _contract from './_contract' ;
+
+export default function* _smallcuts ( G ) {
+
+	let H = G;
+	const id = new Map();
+	for ( const v of G.keys()) id.set(v,[v]);
+
+	while ( H.size >= 2 ) {
+
+		const ordering = list(_order(H));
+		const x = ordering[ordering.length-2][0];
+		const y = ordering[ordering.length-1][0];
+
+		const U = new Set(chain(map( ([u,_]) => id.get(u) , head(ordering,-1) ) ));
+		const V = new Set(id.get(y));
+
+		yield { 'partition' : [ U , V ] , 'size' : ordering[ordering.length-1][1] } ;
+
+		id.set(x, id.get(x).concat(id.get(y)));
+
+		H = _contract(H, list(map(([u,_]) => u , ordering)));
+
+	}
+
+}

src/maxback/_smallcuts.js

@@ -0,0 +1,15 @@
+import _contract from './_contract' ;
+import _order from './_order' ;
+import _smallcuts from './_smallcuts' ;
+import maxback from './maxback' ;
+import mb from './mb' ;
+
+export default maxback ;
+
+export {
+	_contract ,
+	_order ,
+	_smallcuts ,
+	maxback ,
+	mb ,
+} ;

src/maxback/index.js

@@ -0,0 +1,15 @@
+import adj from '../adj';
+import mb from './mb';
+import outgoingedges from '../outgoingedges';
+
+/**
+ * Nagamochi-Ibaraki poly-time algorithm.
+ *
+ * @param edges List of edges of a undirected unweighted connected loopless multigraph G.
+ * @returns {Array} A minimum cut of G.
+ */
+export default function maxback ( edges ) {
+	const G = adj( edges ) ;
+	const { partition : [ U , _ ] } = mb( G ) ;
+	return outgoingedges( G , U ) ;
+}

src/maxback/maxback.js

@@ -0,0 +1,8 @@
+import { min } from '@aureooms/js-itertools' ;
+import { attr , increasing } from '@aureooms/js-compare' ;
+
+import _smallcuts from './_smallcuts' ;
+
+export default function mb ( G ) {
+	return min( attr( increasing , 'size' ) , _smallcuts(G) , undefined ) ;
+}

src/maxback/mb.js

@@ -0,0 +1,3 @@
+export default function* outgoingedges ( G , U ) {
+	for ( const u of U ) for ( const v of G.get(u) ) if ( !U.has(v) ) yield [ u , v ] ;
+}