public static void Compute(LinearDecomposition decomposition)
{
Graph graph = decomposition.Graph;
List<int> sequence = decomposition.Sequence;
int n = graph.Size;
BitSet right = graph.Vertices;
BitSet left = new BitSet(0, n);
LookupTable table = new LookupTable(n);
LinearRepresentativeTable cuts = new LinearRepresentativeTable(graph, sequence);
int l = sequence[0];
BitSet leaf = new BitSet(0, n, new int[] { l });
BitSet nleaf = new BitSet(0, n, new int[] { graph.OpenNeighborhood(l).First() });
table[leaf, new BitSet(0, n), 1] = 1;
table[leaf, nleaf, 1] = 1;
table[new BitSet(0, n), nleaf, 0] = 1;
left += l;
right -= l;
for (int i = 1; i < sequence.Count; i++)
{
int v = sequence[i];
left += v;
right -= v;
LinearRepresentativeList lRw = cuts[left];
LinearRepresentativeList LRw_ = cuts[right];
LinearRepresentativeList lRa = cuts[left - v];
LinearRepresentativeList LRa_ = cuts[right + v];
LookupTable newTable = new LookupTable(n);
foreach (BitSet outside in LRw_)
{
foreach (BitSet inside in lRa)
{
BitSet nrw = graph.Neighborhood(outside) * (left - v);
BitSet ra_ = LRa_.GetRepresentative(nrw);
BitSet nra = graph.Neighborhood(inside) * right;
BitSet rw = lRw.GetRepresentative(nra);
BitSet ra = inside;
BitSet rw_ = outside;
BitSet raw = inside + outside;
BitSet nraw = graph.Neighborhood(raw);
if (nraw.Contains(v)) // this means rb_ exists ==> multiplier is equal to 1
{
for (int ka = 0; ka < n; ka++)
{
newTable[rw, rw_, ka] = newTable[rw, rw_, ka] + table[ra, ra_, ka];
}
}
//--------
nrw = graph.Neighborhood(outside + v) * (left - v);
ra_ = LRa_.GetRepresentative(nrw);
nra = graph.Neighborhood(inside + v) * right;
rw = lRw.GetRepresentative(nra);
for (int ka = 0; ka < n; ka++)
{
newTable[rw, rw_, ka + 1] = newTable[rw, rw_, ka + 1] + table[ra, ra_, ka];
}
}
}
table = newTable;
}
return;
}
public static void Compute(LinearDecomposition decomposition)
{
Graph graph = decomposition.Graph;
List<int> sequence = decomposition.Sequence;
int n = graph.Size;
BitSet right = graph.Vertices;
BitSet left = new BitSet(0, n);
LookupTable table = new LookupTable(n);
LinearRepresentativeTable cuts = new LinearRepresentativeTable(graph, sequence);
table[new BitSet(0, n), 0] = 1;
table[new BitSet(0, n), 1] = 0;
for (int i = 0; i < sequence.Count; i++)
{
int v = sequence[i];
left += v;
right -= v;
LinearRepresentativeList lRw = cuts[left];
LinearRepresentativeList lRa = cuts[left - v];
LookupTable newTable = new LookupTable(n);
foreach (BitSet ra in lRa)
{
BitSet nra = graph.Neighborhood(ra) * right;
BitSet rw = lRw.GetRepresentative(nra);
int maxValue = int.MinValue;
int limit = (left - v).Count;
for (int k = 0; k <= limit; k++)
if (table[ra, k] > 0)
maxValue = Math.Max(maxValue, k);
for (int j = 0; j <= maxValue; j++)
{
newTable[rw, j] = newTable[rw, j] + table[ra, j];
}
//------------
// ra + {v} is not a valid independent set
if (lRa.GetNeighborhood(ra).Contains(v))
continue;
//------------
// add {v} to the independent set
BitSet nrav = graph.Neighborhood(ra + v) * right;
BitSet rwv = lRw.GetRepresentative(nrav);
for (int j = 0; j <= maxValue; j++)
{
newTable[rwv, j + 1] = newTable[rwv, j + 1] + table[ra, j];
}
}
table = newTable;
}
return;
}
public static int Compute(LinearDecomposition decomposition)
{
Graph graph = decomposition.Graph;
int n = graph.Size;
List<int> sequence = decomposition.Sequence;
BitSet left = new BitSet(0, graph.Size);
BitSet right = graph.Vertices;
BitSet vg = graph.Vertices;
LinearRepresentativeTable cuts = new LinearRepresentativeTable(graph, sequence);
LookupTable table = new LookupTable();
// first initialize the very first leaf node
int l = sequence[0];
left += l;
right -= l;
// Base cases
BitSet leaf = new BitSet(0, n, new int[] { l });
BitSet nleaf = new BitSet(0, n, new int[] { graph.OpenNeighborhood(l).First() });
table[new BitSet(0, n), new BitSet(0, n)] = int.MaxValue;
table[leaf, new BitSet(0, n)] = 1;
table[leaf, nleaf] = 1;
table[new BitSet(0, n), nleaf] = 0;
for (int i = 1; i < sequence.Count; i++)
{
int v = sequence[i];
left += v;
right -= v;
LinearRepresentativeList lRw = cuts[left];
LinearRepresentativeList LRw_ = cuts[right];
LinearRepresentativeList lRa = cuts[left - v];
LinearRepresentativeList LRa_ = cuts[right + v];
LookupTable newTable = new LookupTable();
foreach (BitSet outside in LRw_)
{
foreach (BitSet inside in lRa)
{
BitSet nrw = graph.Neighborhood(outside) * (left - v);
BitSet ra = LRa_.GetRepresentative(nrw);
BitSet nra = graph.Neighborhood(inside) * right;
BitSet rw = lRw.GetRepresentative(nra);
int savedValue = newTable[rw, outside];
int newValue = table[inside, ra];
BitSet raw = inside + outside;
BitSet nraw = graph.Neighborhood(raw);
if (!nraw.Contains(v))
newValue = int.MaxValue;
int min = Math.Min(savedValue, newValue);
newTable[rw, outside] = min;
//--------
nrw = graph.Neighborhood(outside + v) * (left - v);
ra = LRa_.GetRepresentative(nrw);
nra = graph.Neighborhood(inside + v) * right;
rw = lRw.GetRepresentative(nra);
savedValue = newTable[rw, outside];
newValue = table[inside, ra];
newValue = newValue == int.MaxValue ? newValue : newValue + 1;
min = Math.Min(savedValue, newValue);
newTable[rw, outside] = min;
}
}
table = newTable;
}
return table[new BitSet(0, graph.Size), new BitSet(0, graph.Size)];
}
