public BreadthFirstPaths(Graph G, IEnumerable<int> sources)
{
marked = new bool[G.V];
edgeTo = new int[G.V];
this.s = new HashSet<int>(sources);
BFS(G, s);
}
public DepthFirstPaths(Graph G, int s)
{
marked = new bool[G.V];
edgeTo = new int[G.V];
this.s = s;
DFS(G, s);
}
public static bool IsIsomorphic(Graph G1, Graph G2)
{
if (G1.V != G2.V) return false;
bool result = false;
return result;
}
public BreadthFirstPaths(Graph G, int source)
{
marked = new bool[G.V];
edgeTo = new int[G.V];
this.s = new HashSet<int>();
s.Add(source);
BFS(G, s);
}
private void DFS(Graph G, int v)
{
marked[v] = true;
id[v] = count;
foreach (var w in G.Adj(v))
if (!marked[w])
DFS(G, w);
}
/// <summary>
/// Departs the graph into two groups if possible and returns true. Otherwise returns false
/// </summary>
public static bool Depart(Graph G, out IEnumerable<int> group1, out IEnumerable<int> group2)
{
marked = new byte[G.V];
List<int> result1 = new List<int>();
List<int> result2 = new List<int>();
bool isBipartite = DFS(G, 0 , ref result1, ref result2, FIRST);
group1 = result1;
group2 = result2;
return isBipartite;
}
private void DFS(Graph G, int v)
{
marked[v] = true;
foreach (var w in G.Adj(v))
{
if (!marked[w])
{
DFS(G, w);
edgeTo[w] = v;
}
}
}
public ConnectedComponents(Graph G)
{
marked = new bool[G.V];
id = new int[G.V];
for (int v = 0; v < G.V; v++)
{
if (!marked[v])
{
DFS(G, v);
count++;
}
}
}
private static bool DFS( Graph G,int v, ref List<int> G1, ref List<int> G2, byte mark)
{
marked[v] = mark;
G1.Add(v);
bool result = true;
foreach (var w in G.Adj(v))
{
if (marked[w] != 0 && marked[w] == mark) return false;
if (marked[w] == 0)
{
result = result && DFS(G, w, ref G2, ref G1, mark == FIRST? SECOND: FIRST);
}
}
return result;
}
private void BFS(Graph G, IEnumerable<int> sources)
{
Queue<int> q = new Queue<int>();
foreach (int source in sources)
{
q.Enqueue(source);
}
while (!(q.Count == 0))
{
int v = q.Dequeue();
foreach (int w in G.Adj(v))
{
if (!marked[w])
{
q.Enqueue(w);
marked[w] = true;
edgeTo[w] = v;
}
}
}
}
public static void ClassInit(TestContext context)
{
basicGraph = new Graph(9);
basicGraph.AddEdge(0, 1);
basicGraph.AddEdge(0, 2);
basicGraph.AddEdge(0, 5);
basicGraph.AddEdge(0, 6);
basicGraph.AddEdge(2, 7);
basicGraph.AddEdge(6, 4);
basicGraph.AddEdge(4, 3);
basicGraph.AddEdge(4, 5);
baseicDigraph = new Digraph(7);
baseicDigraph.AddEdge(5, 0);
baseicDigraph.AddEdge(2, 4);
baseicDigraph.AddEdge(3, 2);
baseicDigraph.AddEdge(1, 2);
baseicDigraph.AddEdge(0, 1);
baseicDigraph.AddEdge(4, 3);
baseicDigraph.AddEdge(3, 5);
baseicDigraph.AddEdge(0, 2);
baseicDigraph.AddEdge(6, 5);
}
public void Isomorphic_Test()
{
var G1 = new Graph(7);
G1.AddEdge(0, 1);
G1.AddEdge(0, 2);
G1.AddEdge(0, 6);
G1.AddEdge(0, 5);
G1.AddEdge(4, 5);
G1.AddEdge(4, 3);
G1.AddEdge(4, 6);
G1.AddEdge(3, 5);
var G2 = new Graph(7);
G2.AddEdge(4, 0);
G2.AddEdge(4, 1);
G2.AddEdge(4, 2);
G2.AddEdge(4, 3);
G2.AddEdge(5, 0);
G2.AddEdge(5, 1);
G2.AddEdge(5, 6);
G2.AddEdge(0, 6);
Assert.IsTrue(Isomorphic.IsIsomorphic(G1, G2));
Assert.IsFalse(Isomorphic.IsIsomorphic(G1, basicGraph));
Assert.IsFalse(Isomorphic.IsIsomorphic(G2, basicGraph));
}
public void Graph_API_Test()
{
Graph G = new Graph(3);
G.AddEdge(0, 1);
G.AddEdge(0, 2);
List<int> e = new List<int>(G.Adj(0));
Assert.AreEqual(1, e[0]);
}
public void Bipartite_Test()
{
var BG = new Graph(7);
BG.AddEdge(0, 1);
BG.AddEdge(0, 2);
BG.AddEdge(0, 5);
BG.AddEdge(0, 6);
BG.AddEdge(2, 3);
BG.AddEdge(2, 4);
BG.AddEdge(1, 3);
BG.AddEdge(4, 6);
BG.AddEdge(4, 5);
IEnumerable<int> G1;
IEnumerable<int> G2;
bool actual = BipartiteGraph.Depart(BG, out G1, out G2);
Assert.IsTrue(actual);
}
