GetSeparationTree(PlanarGraph pg, PlanarNode src) //1610738 78794
{
pg = Triangulation.GetTriangulation(pg);
PlanarEdge ww = pg.planarEdges[1630674];
Dictionary <PlanarEdge, int> cyclesTriEdges
= new Dictionary <PlanarEdge, int>();
StreamReader r = new StreamReader("C:\\Users\\L\\Desktop\\triCycles.txt");
while (!r.EndOfStream)
{
string line = r.ReadLine();
string[] spl = line.Split(new char[] { ' ' },
StringSplitOptions.RemoveEmptyEntries);
cyclesTriEdges.Add(
pg.planarEdges[int.Parse(spl[0])], int.Parse(spl[0]));
}
int max = cyclesTriEdges.Values.Max();
KeyValuePair <PlanarEdge, int> maxTriE
= cyclesTriEdges.Where(x => x.Value == max).First();
cyclesTriEdges.Remove(maxTriE.Key);
SeparatorCycle cycle = new SeparatorCycle(pg);
List <PlanarNode> inC;
List <PlanarNode> outC;
List <PlanarNode> sep = cycle.SeparateByEdge(
pg.planarEdges[1630674], pg.planarNodes.First().Value, out inC, out outC);
return(null);
// DecompositionTreeItem rootIte
}
private static void RecursiveSeparation(PlanarGraph pg,
PlanarNode src,
List <PlanarNode> orderNodes, SeparatorCycle sepCycle)
{
PlanarEdge sepE;
Bfs.Src_all_bfs(src, pg.planarNodes, pg.planarEdges, true);
if (pg.planarNodes.Count < nodesCount / 10 ||
!FindSeparator(src, orderNodes, pg, sepCycle, out sepE))
{
Console.WriteLine("Leaf:" + gc + " " + pg.planarNodes.Count);
return;
}
List <PlanarNode> cycleNodes
= sepCycle.cycle
.Where(x => pg.planarNodes.Keys.Contains(x))
.Select(x => pg.planarNodes[x]).ToList();
gc++;
PlanarGraph g0 = new PlanarGraph(sepCycle.inC, cycleNodes, src,
new Dictionary <int, PlanarEdge>(pg.planarEdges));
PlanarGraph g1 = new PlanarGraph(sepCycle.outC, cycleNodes, src,
new Dictionary <int, PlanarEdge>(pg.planarEdges));
RecursiveSeparation(g0, g0.planarNodes[srcId], orderNodes, sepCycle);
gc++;
Bfs.Src_all_bfs(src, pg.planarNodes, pg.planarEdges, true);
RecursiveSeparation(g1, g1.planarNodes[srcId], orderNodes, sepCycle);
}
private static bool FindSeparatorOnTriangulation(PlanarNode src,
PlanarGraph pg,
SeparatorCycle sepCycle)
{
pg = Triangulation.GetTriangulation(pg);
foreach (PlanarEdge f in Triangulation.triEdges)
{
if (((PlanarNode)f.neighboursAdjEdges[0]).nid == srcId ||
((PlanarNode)f.neighboursAdjEdges[1]).nid == srcId)
{
continue;
}
PlanarNode src2 = pg.planarNodes[srcId];
Bfs.Src_all_bfs(src2, pg.planarNodes, pg.planarEdges, true);
sepCycle.GetBoundaryCycle(pg, src2, f);
int max = (int)(c * pg.planarNodes.Count);
if (sepCycle.inC.Count < max &&
sepCycle.outC.Count < max)
{
Console.WriteLine(gc + " " + sepCycle.inC.Count);
// ResetGraph(pg);
return(true);
}
ResetGraph(pg);
// break;
}
Console.WriteLine("not: " + gc + " " + pg.planarNodes.Count);
return(false);
}
private static bool FindSeparator(PlanarNode src,
List <PlanarNode> orderNodes, PlanarGraph pg,
SeparatorCycle sepCycle, out PlanarEdge f)
{
List <PlanarNode> insideBoundaryNodes =
orderNodes
.Where(y => pg.planarNodes.ContainsKey(y.nid)).ToList();
for (int i = 0; i < insideBoundaryNodes.Count - 1; i = i + 1)
{
for (int j = i + 1; j < insideBoundaryNodes.Count; j = j + 1)
{
PlanarNode src2 = pg.planarNodes[srcId];
Bfs.Src_all_bfs(src2, pg.planarNodes, pg.planarEdges, true);
PlanarNode u = pg.planarNodes[insideBoundaryNodes[i].nid];
PlanarNode v = pg.planarNodes[insideBoundaryNodes[j].nid];
f = new PlanarEdge(u, v);
f.eid = -pg.planarEdges.Count - 1;
f.trgl = true;
pg.planarEdges.Add(f.eid, f);
u.edgesIds.Add(f.eid);
v.edgesIds.Add(f.eid);
// SeparatorCycle sepCycle = new SeparatorCycle();
sepCycle.GetBoundaryCycle(pg, src2, f);
int max = (int)(c * pg.planarNodes.Count);
if (sepCycle.inC.Count < max &&
sepCycle.outC.Count < max)
{
Console.WriteLine(gc + " " + sepCycle.inC.Count + " " + u.nid + " " + v.nid);
// ResetGraph(pg);
return(true);
}
else
{
u.edgesIds.Remove(f.eid);
v.edgesIds.Remove(f.eid);
}
ResetGraph(pg);
// break;
}
}
f = null;
if (c == 4f / 5)
{
c = 19f / 20;
return(FindSeparator(src, orderNodes, pg, sepCycle, out f));
}
else
{
// c = 4f / 5;
Console.WriteLine("not: " + gc + " " + pg.planarNodes.Count);
return(FindSeparatorOnTriangulation(src, pg, sepCycle));
}
}
public static void GetDecompositionTree(PlanarGraph pg, Graph g)
{
nodesCount = g.nodes.Count();
List <PlanarNode> orderNodes = OrderBoundaryNodes(pg, g, srcId);
PlanarNode src = pg.planarNodes[srcId]; // .First().Value;
srcId = src.nid;
SeparatorCycle sepCycle = new SeparatorCycle();
RecursiveSeparation(pg, src, orderNodes, sepCycle);
Console.ReadKey();
}
public static void GetDecomposition(PlanarGraph g, PlanarNode src)
{
PlanarSeparator sep = new PlanarSeparator();
List <long> cycle;
// Bfs.Src_all_bfs(g.planarNodes.First().Value, g.planarEdges, true);
SeparatorCycle c = new SeparatorCycle();
c.GetCycle_U_V(g, g.planarNodes[3682132103], g.planarNodes[34073500]);
cycle = c.cycle;
Dictionary <long, PlanarNode> nodes
= new Dictionary <long, PlanarNode>(g.planarNodes);
List <long> nullKeys = new List <long>();
foreach (KeyValuePair <long, PlanarNode> pair in nodes)
{
PlanarNode n = pair.Value;
if (n == null || n.edgesIds.Count == 0)
{
nullKeys.Add(pair.Key);
continue;
}
n.state = 0;
n.dist = 0;
}
foreach (long nid in nullKeys)
{
nodes.Remove(nid);
}
foreach (long nid in cycle)
{
nodes.Remove(nid);
}
Dictionary <long, List <long> > components = new Dictionary <long, List <long> >();
foreach (PlanarNode x in nodes.Values)
{
if (x.state > 0)
{
continue;
}
// Bfs.Src_all_bfs(x, g.planarEdges, false);
List <long> comp = Bfs.part0;
components.Add(x.nid, comp);
}
int max = 0;
long maxKey = 0;
foreach (KeyValuePair <long, List <long> > pair in components)
{
if (nodes.ContainsKey(pair.Key) && pair.Value.Count > max)
{
max = pair.Value.Count;
maxKey = pair.Key;
}
}
PlanarNode s0 = nodes.Last().Value;
}
