func (g Undirected) BKPivotMaxDegree(P, X *Bits) (p NI) {
	a := g.AdjacencyList
	maxDeg := -1
	P.Iterate(func(n NI) bool {  
		if d := len(a[n]); d > maxDeg {
			p = n
			maxDeg = d
		}
		return true
	})
	X.Iterate(func(n NI) bool {  
		if d := len(a[n]); d > maxDeg {
			p = n
			maxDeg = d
		}
		return true
	})
	return
}
BKPivotMaxDegree is a strategy for BronKerbosch methods.

To use it, take the method value (see golang.org/ref/spec#Method_values)
and pass it as the argument to BronKerbosch2 or 3.

The strategy is to pick the node from P or X with the maximum degree
(number of edges) in g.  Note this is a shortcut from evaluating degrees
in P.

There are equivalent labeled and unlabeled versions of this method.
package graph
func (g Undirected) Bipartite(n NI) (b bool, c1, c2 Bits, oc []NI) {
	b = true
	var open bool
	var df func(n NI, c1, c2 *Bits)
	df = func(n NI, c1, c2 *Bits) {
		c1.SetBit(n, 1)
		for _, nb := range g.AdjacencyList[n] {
			if c1.Bit(nb) == 1 {
				b = false
				oc = []NI{nb, n}
				open = true
				return
			}
			if c2.Bit(nb) == 1 {
				continue
			}
			df(nb, c2, c1)
			if b {
				continue
			}
			switch {
			case !open:
			case n == oc[0]:
				open = false
			default:
				oc = append(oc, n)
			}
			return
		}
	}
	df(n, &c1, &c2)
	if b {
		return b, c1, c2, nil
	}
	return b, Bits{}, Bits{}, oc
}
func (g Undirected) BronKerbosch1(emit func([]NI) bool) {
	a := g.AdjacencyList
	var f func(R, P, X *Bits) bool
	f = func(R, P, X *Bits) bool {
		switch {
		case !P.Zero():
			var r2, p2, x2 Bits
			pf := func(n NI) bool {
				r2.Set(*R)
				r2.SetBit(n, 1)
				p2.Clear()
				x2.Clear()
				for _, to := range a[n] {
					if P.Bit(to) == 1 {
						p2.SetBit(to, 1)
					}
					if X.Bit(to) == 1 {
						x2.SetBit(to, 1)
					}
				}
				if !f(&r2, &p2, &x2) {
					return false
				}
				P.SetBit(n, 0)
				X.SetBit(n, 1)
				return true
			}
			if !P.Iterate(pf) {
				return false
			}
		case X.Zero():
			return emit(R.Slice())
		}
		return true
	}
	var R, P, X Bits
	P.SetAll(len(a))
	f(&R, &P, &X)
}