public void BreadthFirstPathsTest1()
{
Graph g = TestHelpers.buildGraph();
BreadthFirstPaths bfps;
bfps = new BreadthFirstPaths(g, 0);
Assert.AreEqual(0, bfps.DistTo(0));
Assert.AreEqual(1, bfps.DistTo(1));
Assert.AreEqual(3, bfps.DistTo(4));
Assert.AreEqual(int.MaxValue, bfps.DistTo(10));
Assert.AreEqual(int.MaxValue, bfps.DistTo(12));
Assert.AreEqual(int.MaxValue, bfps.DistTo(5));
bfps = new BreadthFirstPaths(g, 10);
Assert.IsTrue(bfps.HasPathTo(11));
Assert.AreEqual(1, bfps.DistTo(11));
bfps = new BreadthFirstPaths(g, 12);
Assert.AreEqual(2, bfps.DistTo(15));
Assert.IsFalse(bfps.HasPathTo(11));
Assert.IsFalse(bfps.HasPathTo(3));
Assert.IsFalse(bfps.HasPathTo(9));
}
public static void DoTest()
{
IGraph<string> graph = new UndirectedSparseGraph<string>();
// Add vertices
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v", "w", "m" };
graph.AddVertices (verticesSet1);
// Add edges
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "w");
graph.AddEdge("x", "m");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("v", "f");
graph.AddEdge("w", "m");
var sourceNode = "f";
var bfsPaths = new BreadthFirstPaths<string> (graph, sourceNode);
Console.WriteLine ("Distance from '" + sourceNode + "' to 'a' is: " + bfsPaths.DistanceTo ("a"));
Console.WriteLine ("Path from '" + sourceNode + "' to 'a' is : " + printPath(bfsPaths.ShortestPathTo("a")));
Console.WriteLine ();
Console.WriteLine ("Distance from '" + sourceNode + "' to 'w' is: " + bfsPaths.DistanceTo ("w"));
Console.WriteLine ("Path from '" + sourceNode + "' to 'w' is : " + printPath(bfsPaths.ShortestPathTo("w")));
}
public static void DoTest()
{
IGraph <string> graph = new UndirectedSparseGraph <string>();
// Add vertices
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v", "w", "m" };
graph.AddVertices(verticesSet1);
// Add edges
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("x", "w");
graph.AddEdge("x", "m");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("v", "f");
graph.AddEdge("w", "m");
var sourceNode = "f";
var bfsPaths = new BreadthFirstPaths <string> (graph, sourceNode);
Console.WriteLine("Distance from '" + sourceNode + "' to 'a' is: " + bfsPaths.DistanceTo("a"));
Console.WriteLine("Path from '" + sourceNode + "' to 'a' is : " + printPath(bfsPaths.ShortestPathTo("a")));
Console.WriteLine();
Console.WriteLine("Distance from '" + sourceNode + "' to 'w' is: " + bfsPaths.DistanceTo("w"));
Console.WriteLine("Path from '" + sourceNode + "' to 'w' is : " + printPath(bfsPaths.ShortestPathTo("w")));
}
static void Main(String[] args)
{
/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution */
int n = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < n; i++)
{
string str = Console.ReadLine();
string[] num = str.Split(' ');
Graph g = new Graph(Convert.ToInt32(num[0]));
int e = Convert.ToInt32(num[1]);
for (int j = 0; j < e; j++)
{
str = Console.ReadLine();
num = str.Split(' ');
g.addEdge(Convert.ToInt32(num[0]) - 1, Convert.ToInt32(num[1]) - 1);
}
int s = Convert.ToInt32(Console.ReadLine()) - 1;
//Console.WriteLine("F**k {0}", s);
BreadthFirstPaths bfs = new BreadthFirstPaths(g, s);
for (int j = 0; j < g.V(); j++)
{
if (bfs.hasPath(j) && j != s)
{
Console.Write("{0} ", bfs.DistTo(j) * 6);
}
else if (!bfs.hasPath(j) && j != s)
{
Console.Write("{0} ", -1);
}
}
Console.WriteLine();
}
}
/**************************************************************************
*
* The code below is solely for testing correctness of the data type.
*
**************************************************************************/
// Determines whether a digraph has an Eulerian path using necessary
// and sufficient conditions (without computing the path itself):
// - indegree(v) = outdegree(v) for every vertex,
// except one vertex v may have outdegree(v) = indegree(v) + 1
// (and one vertex v may have indegree(v) = outdegree(v) + 1)
// - the graph is connected, when viewed as an undirected graph
// (ignoring isolated vertices)
private static boolean satisfiesNecessaryAndSufficientConditions(Digraph G) {
if (G.E() == 0) return true;
// Condition 1: indegree(v) == outdegree(v) for every vertex,
// except one vertex may have outdegree(v) = indegree(v) + 1
int deficit = 0;
for (int v = 0; v < G.V(); v++)
if (G.outdegree(v) > G.indegree(v))
deficit += (G.outdegree(v) - G.indegree(v));
if (deficit > 1) return false;
// Condition 2: graph is connected, ignoring isolated vertices
Graph H = new Graph(G.V());
for (int v = 0; v < G.V(); v++)
for (int w : G.adj(v))
H.addEdge(v, w);
// check that all non-isolated vertices are connected
int s = nonIsolatedVertex(G);
BreadthFirstPaths bfs = new BreadthFirstPaths(H, s);
for (int v = 0; v < G.V(); v++)
if (H.degree(v) > 0 && !bfs.hasPathTo(v))
return false;
return true;
}
public void bfsTest()
{
using (StreamReader sr = new StreamReader(@"E:\Study\ALG2017\ALGRKC\dataSelf\tinyCG.txt"))
{
Graph g = new Graph(sr);
int source = 0;
BreadthFirstPaths bfp = new BreadthFirstPaths(g, source);
bfp.bfs(g, source);
for (int i = 0; i < g.V(); i++)
{
Console.Write(source + " to " + i + " : ");
if (bfp.HasPathTo(i))
{
foreach (int v in bfp.PathTo(i))
{
if (v == source)
{
Console.Write(source);
}
else
{
Console.Write("-" + v);
}
}
Console.WriteLine();
}
else
{
Console.WriteLine("no path");
}
}
}
}
void Start()
{
Graph G = new Graph(txt);
int s = 0;
BreadthFirstPaths bfs = new BreadthFirstPaths(G, s);
for (int v = 0; v < G.V(); v++)
{
if (bfs.hasPathTo(v))
{
//print("%d to %d (%d): ", s, v, bfs.DistTo(v));
string str = s + " to " + v + "\tdistance:" + bfs.DistTo(v) + "\t.\t";
foreach (int x in bfs.pathTo(v))
{
if (x == s)
{
str += x;
}
else
{
str += ("-" + x);
}
}
print(str);
}
else
{
print(s + " to " + v + ": not connected\n");
}
}
}
static void Main(string[] args)
{
Graph g = GetGraph();
int[] paths;
Paths path;
path = new DepthFirstPaths(g, 0);
paths = path.PathTo(4);
path = new BreadthFirstPaths(g, 0);
paths = path.PathTo(4);
Console.ReadKey();
}
public void BFS_Test()
{
BreadthFirstPaths BFS = new BreadthFirstPaths(basicGraph, 0);
Assert.IsTrue(BFS.HasPathTo(3));
Assert.IsFalse(BFS.HasPathTo(8));
var path = BFS.PathTo(7);
var SB = new StringBuilder();
foreach (int v in path)
{
SB.Append(v.ToString());
}
Assert.AreEqual("027", SB.ToString());
}
public void BreadthFirstPathsTest()
{
var g = GraphSample();
var bfs = new BreadthFirstPaths(g, 0);
Assert.True(bfs.HasPathTo(5));
var path = bfs.PathTo(5);
int[] result = { 5, 0 };
int i = 0;
foreach (int v in path)
{
Assert.Equal(result[i], v);
i++;
}
}
public void TestCase1()
{
var g = new Graph(6);
g.AddEdge(0, 5);
g.AddEdge(2, 4);
g.AddEdge(2, 3);
g.AddEdge(1, 2);
g.AddEdge(0, 1);
g.AddEdge(3, 4);
g.AddEdge(3, 5);
g.AddEdge(0, 2);
var bfsPaths = new BreadthFirstPaths(g, 0);
var expected = new int[] { 0, 2, 4 };
var actual = bfsPaths.PathTo(4).ToArray();
Assert.Equal(expected, actual);
}
/**/ public static void main(string[] strarr)
{
string str = strarr[0];
string str2 = strarr[1];
string str3 = strarr[2];
SymbolGraph symbolGraph = new SymbolGraph(str, str2);
Graph g = symbolGraph.G();
if (!symbolGraph.contains(str3))
{
StdOut.println(new StringBuilder().append(str3).append(" not in database.").toString());
return;
}
int i = symbolGraph.index(str3);
BreadthFirstPaths breadthFirstPaths = new BreadthFirstPaths(g, i);
while (!StdIn.isEmpty())
{
string str4 = StdIn.readLine();
if (symbolGraph.contains(str4))
{
int i2 = symbolGraph.index(str4);
if (breadthFirstPaths.hasPathTo(i2))
{
Iterator iterator = breadthFirstPaths.pathTo(i2).iterator();
while (iterator.hasNext())
{
int i3 = ((Integer)iterator.next()).intValue();
StdOut.println(new StringBuilder().append(" ").append(symbolGraph.name(i3)).toString());
}
}
else
{
StdOut.println("Not connected");
}
}
else
{
StdOut.println(" Not in database.");
}
}
}
/**/ public static void main(string[] strarr)
{
In i = new In(strarr[0]);
Graph graph = new Graph(i);
int num = Integer.parseInt(strarr[1]);
BreadthFirstPaths breadthFirstPaths = new BreadthFirstPaths(graph, num);
for (int j = 0; j < graph.V(); j++)
{
if (breadthFirstPaths.hasPathTo(j))
{
StdOut.printf("%d to %d (%d): ", new object[]
{
Integer.valueOf(num),
Integer.valueOf(j),
Integer.valueOf(breadthFirstPaths.distTo(j))
});
Iterator iterator = breadthFirstPaths.pathTo(j).iterator();
while (iterator.hasNext())
{
int num2 = ((Integer)iterator.next()).intValue();
if (num2 == num)
{
StdOut.print(num2);
}
else
{
StdOut.print(new StringBuilder().append("-").append(num2).toString());
}
}
StdOut.println();
}
else
{
StdOut.printf("%d to %d (-): not connected\n", new object[]
{
Integer.valueOf(num),
Integer.valueOf(j)
});
}
}
}
public void BFS_MultiSource_Test()
{
var sources = new HashSet <int>()
{
0, 3
};
BreadthFirstPaths BFS = new BreadthFirstPaths(basicGraph, sources);
Assert.IsTrue(BFS.HasPathTo(3));
Assert.IsFalse(BFS.HasPathTo(8));
var path = BFS.PathTo(7);
var SB = new StringBuilder();
foreach (int v in path)
{
SB.Append(v.ToString());
}
Assert.AreEqual("027", SB.ToString());
Stack <int> path4 = (Stack <int>)BFS.PathTo(4); //We know that returned type is an stack
Assert.AreEqual(3, path4.Pop());
}
void Start()
{
string source = "JFK";
SymbolGraph sg = new SymbolGraph(txt);
Graph G = sg.Graph();
if (!sg.Contains(source))
{
print(source + " not in database.");
return;
}
int s = sg.IndexOf(source);
BreadthFirstPaths bfs = new BreadthFirstPaths(G, s);
string sink = "DFW";
if (sg.Contains(sink))
{
int t = sg.IndexOf(sink);
if (bfs.hasPathTo(t))
{
foreach (int v in bfs.pathTo(t))
{
print(" " + sg.NameOf(v));
}
}
else
{
print("Not connected");
}
}
else
{
print(" Not in database.");
}
}
private static void SeverLink(Graph graph, int skyNetLocation)
{
var bfp = new BreadthFirstPaths(graph, skyNetLocation);
var shortestExit = -1;
var exitLength = Int32.MaxValue;
foreach (var exit in graph.Exits)
{
if (bfp.HasPathTo(exit))
{
var currLen = bfp.PathTo(exit).Count();
if (currLen < exitLength)
{
exitLength = currLen;
shortestExit = exit;
}
}
}
var targetNode = bfp.PathTo(shortestExit).Skip(1).First();
graph.RemoveEdge(skyNetLocation, targetNode);
Console.WriteLine("{0} {1}", skyNetLocation, targetNode);
}
public void Testing()
{
var graph = new UndirectedGraph(13);
graph.InsertEdge(0, 5);
graph.InsertEdge(4, 3);
graph.InsertEdge(0, 1);
graph.InsertEdge(9, 12);
graph.InsertEdge(6, 4);
graph.InsertEdge(5, 4);
graph.InsertEdge(0, 2);
graph.InsertEdge(11, 12);
graph.InsertEdge(9, 10);
graph.InsertEdge(0, 6);
graph.InsertEdge(7, 8);
graph.InsertEdge(9, 11);
graph.InsertEdge(5, 3);
var degree = graph.VertexDegree(5);
var maxDegree = graph.GraphMaxVertexDegree();
var avgDegree = graph.GraphAverageVertexDegree();
var selfLoops = graph.GraphNumberOfSelfLoops();
var graph2 = new UndirectedGraph(6);
graph2.InsertEdge(0, 5);
graph2.InsertEdge(2, 4);
graph2.InsertEdge(2, 3);
graph2.InsertEdge(1, 2);
graph2.InsertEdge(0, 1);
graph2.InsertEdge(3, 4);
graph2.InsertEdge(3, 5);
graph2.InsertEdge(0, 2);
var depthFirstSearch = new DepthFirstSearch(graph2, 0);
var depthFirstSearchCount = depthFirstSearch.Count();
var depthFirstSearchTest0 = depthFirstSearch.Marked(0);
var depthFirstSearchTest1 = depthFirstSearch.Marked(1);
var depthFirstSearchTest2 = depthFirstSearch.Marked(2);
var depthFirstSearchTest3 = depthFirstSearch.Marked(3);
var depthFirstSearchTest4 = depthFirstSearch.Marked(4);
var depthFirstSearchTest5 = depthFirstSearch.Marked(5);
var depthFirstSearchNonRecursive = new DepthFirstSearchNonRecursive(graph2, 0);
var depthFirstSearchNonRecursiveCount = depthFirstSearchNonRecursive.Count();
var depthFirstSearchNonRecursiveTest0 = depthFirstSearchNonRecursive.Marked(0);
var depthFirstSearchNonRecursiveTest1 = depthFirstSearchNonRecursive.Marked(1);
var depthFirstSearchNonRecursiveTest2 = depthFirstSearchNonRecursive.Marked(2);
var depthFirstSearchNonRecursiveTest3 = depthFirstSearchNonRecursive.Marked(3);
var depthFirstSearchNonRecursiveTest4 = depthFirstSearchNonRecursive.Marked(4);
var depthFirstSearchNonRecursiveTest5 = depthFirstSearchNonRecursive.Marked(5);
var depthFirstSearchTestConnected = depthFirstSearchCount == graph2.Vertices ? "Connected" : "NOT Connected";
var depthFirstPath = new DepthFirstPaths(graph2, 0);
var depthFirstPathTest = depthFirstPath.PathTo(4);
var breadthFirstSearch = new BreadthFirstSearch(graph2, 0);
var breadthFirstSearchCount = breadthFirstSearch.Count();
var breadthFirstSearchTest0 = breadthFirstSearch.Marked(0);
var breadthFirstSearchTest1 = breadthFirstSearch.Marked(1);
var breadthFirstSearchTest2 = breadthFirstSearch.Marked(2);
var breadthFirstSearchTest3 = breadthFirstSearch.Marked(3);
var breadthFirstSearchTest4 = breadthFirstSearch.Marked(4);
var breadthFirstSearchTest5 = breadthFirstSearch.Marked(5);
var breadthFirstSearchTestConnected = breadthFirstSearchCount == graph2.Vertices ? "Connected" : "NOT Connected";
var breadthFirstPath = new BreadthFirstPaths(graph2, 0);
var breadthFirstPathTest = breadthFirstPath.PathTo(4);
var depthFirstComponents = new DepthFirstComponents(graph);
var depthFirstComponentsTest0 = depthFirstComponents.IsConnected(0, 7);
var depthFirstComponentsTest1 = depthFirstComponents.IsConnected(0, 6);
var depthFirstComponentsTest2 = depthFirstComponents.IsConnected(7, 9);
var depthFirstComponentsTest3 = depthFirstComponents.IsConnected(7, 8);
var depthFirstComponentsTest4 = depthFirstComponents.IsConnected(9, 0);
var depthFirstComponentsTest5 = depthFirstComponents.IsConnected(9, 12);
var depthFirstCycle = new DepthFirstCycle(graph);
var depthFirstCycleTest = depthFirstCycle.HasCycle();
var depthFirstBipartite = new DepthFirstBipartite(graph);
var depthFirstBipartiteTest = depthFirstBipartite.IsBipartite();
var symbolGraph = new SymbolGraph();
symbolGraph.Insert(new [] { "JFK", "MCO" });
symbolGraph.Insert(new[] { "ORD", "DEN" });
symbolGraph.Insert(new[] { "ORD", "HOU" });
symbolGraph.Insert(new[] { "DFW", "PHX" });
symbolGraph.Insert(new[] { "JFK", "ATL" });
symbolGraph.Insert(new[] { "ORD", "DFW" });
symbolGraph.Insert(new[] { "ORD", "PHX" });
symbolGraph.Insert(new[] { "ATL", "HOU" });
symbolGraph.Insert(new[] { "DEN", "PHX" });
symbolGraph.Insert(new[] { "PHX", "LAX" });
symbolGraph.Insert(new[] { "JFK", "ORD" });
symbolGraph.Insert(new[] { "DEN", "LAS" });
symbolGraph.Insert(new[] { "DFW", "HOU" });
symbolGraph.Insert(new[] { "ORD", "ATL" });
symbolGraph.Insert(new[] { "LAS", "LAX" });
symbolGraph.Insert(new[] { "ATL", "MCO" });
symbolGraph.Insert(new[] { "HOU", "MCO" });
symbolGraph.Insert(new[] { "LAS", "PHX" });
symbolGraph.Build();
var symbolGraphTest0 = symbolGraph.Contains("LAS");
var symbolGraphTest1 = symbolGraph.Contains("MOO");
var symbolGraphTest2 = symbolGraph.Index("LAX");
var symbolGraphTest3 = symbolGraph.Name(symbolGraphTest2);
var symbolGraph2 = new SymbolGraphDegreesOfSeparation();
symbolGraph2.Insert(new[] { "JFK", "MCO" });
symbolGraph2.Insert(new[] { "ORD", "DEN" });
symbolGraph2.Insert(new[] { "ORD", "HOU" });
symbolGraph2.Insert(new[] { "DFW", "PHX" });
symbolGraph2.Insert(new[] { "JFK", "ATL" });
symbolGraph2.Insert(new[] { "ORD", "DFW" });
symbolGraph2.Insert(new[] { "ORD", "PHX" });
symbolGraph2.Insert(new[] { "ATL", "HOU" });
symbolGraph2.Insert(new[] { "DEN", "PHX" });
symbolGraph2.Insert(new[] { "PHX", "LAX" });
symbolGraph2.Insert(new[] { "JFK", "ORD" });
symbolGraph2.Insert(new[] { "DEN", "LAS" });
symbolGraph2.Insert(new[] { "DFW", "HOU" });
symbolGraph2.Insert(new[] { "ORD", "ATL" });
symbolGraph2.Insert(new[] { "LAS", "LAX" });
symbolGraph2.Insert(new[] { "ATL", "MCO" });
symbolGraph2.Insert(new[] { "HOU", "MCO" });
symbolGraph2.Insert(new[] { "LAS", "PHX" });
symbolGraph2.Insert(new[] { "ZZZ", "YYY" });
symbolGraph2.Build();
var symbolGraph2Test0 = symbolGraph2.IsConnected("JFK", "LAS");
var symbolGraph2Test1 = symbolGraph2.IsConnected("JFK", "DFW");
var symbolGraph2Test2 = symbolGraph2.IsConnected("HOU", "YYY");
}
public void Testing()
{
var graph = new DirectedGraph(13);
graph.InsertEdge(4, 2);
graph.InsertEdge(2, 3);
graph.InsertEdge(3, 2);
graph.InsertEdge(6, 0);
graph.InsertEdge(0, 1);
graph.InsertEdge(2, 0);
graph.InsertEdge(11, 12);
graph.InsertEdge(12, 9);
graph.InsertEdge(9, 10);
graph.InsertEdge(9, 11);
graph.InsertEdge(8, 9);
graph.InsertEdge(10, 12);
graph.InsertEdge(11, 4);
graph.InsertEdge(4, 3);
graph.InsertEdge(3, 5);
graph.InsertEdge(7, 8);
graph.InsertEdge(8, 7);
graph.InsertEdge(5, 4);
graph.InsertEdge(0, 5);
graph.InsertEdge(6, 4);
graph.InsertEdge(6, 9);
graph.InsertEdge(7, 6);
var vertexOutDegree = graph.VertexOutDegree(6);
var vertexInDegre = graph.VertexInDegree(6);
var graphReveresed = graph.Reverse();
var depthFirstSearch = new DepthFirstSearch(graph, 0);
var depthFirstSearchCount = depthFirstSearch.Count();
var depthFirstSearchTest0 = depthFirstSearch.Marked(0);
var depthFirstSearchTest1 = depthFirstSearch.Marked(1);
var depthFirstSearchTest2 = depthFirstSearch.Marked(2);
var depthFirstSearchTest3 = depthFirstSearch.Marked(3);
var depthFirstSearchTest4 = depthFirstSearch.Marked(4);
var depthFirstSearchTest5 = depthFirstSearch.Marked(5);
var depthFirstSearchTest6 = depthFirstSearch.Marked(6);
var depthFirstSearchTestConnected = depthFirstSearchCount == graph.Vertices ? "Connected" : "NOT Connected";
var depthFirstPath = new DepthFirstPaths(graph, 0);
var depthFirstPathTest = depthFirstPath.PathTo(2);
var breadthFirstSearch = new BreadthFirstSearch(graph, 0);
var breadthFirstSearchCount = breadthFirstSearch.Count();
var breadthFirstSearchTest0 = breadthFirstSearch.Marked(0);
var breadthFirstSearchTest1 = breadthFirstSearch.Marked(1);
var breadthFirstSearchTest2 = breadthFirstSearch.Marked(2);
var breadthFirstSearchTest3 = breadthFirstSearch.Marked(3);
var breadthFirstSearchTest4 = breadthFirstSearch.Marked(4);
var breadthFirstSearchTest5 = breadthFirstSearch.Marked(5);
var breadthFirstSearchTest6 = breadthFirstSearch.Marked(6);
var breadthFirstSearchTestConnected = breadthFirstSearchCount == graph.Vertices ? "Connected" : "NOT Connected";
var breadthFirstPath = new BreadthFirstPaths(graph, 0);
var breadthFirstPathTest = breadthFirstPath.PathTo(2);
var depthFirstCycle = new DepthFirstCycle(graph);
var depthFirstCycleTest0 = depthFirstCycle.HasCycle();
var depthFirstCycleTest1 = depthFirstCycle.Cycle();
var graph2 = new DirectedGraph(13);
graph2.InsertEdge(2, 3);
graph2.InsertEdge(0, 6);
graph2.InsertEdge(0, 1);
graph2.InsertEdge(2, 0);
graph2.InsertEdge(11, 12);
graph2.InsertEdge(9, 12);
graph2.InsertEdge(9, 10);
graph2.InsertEdge(9, 11);
graph2.InsertEdge(3, 5);
graph2.InsertEdge(8, 7);
graph2.InsertEdge(5, 4);
graph2.InsertEdge(0, 5);
graph2.InsertEdge(6, 4);
graph2.InsertEdge(6, 9);
graph2.InsertEdge(7, 6);
var depthFirstCycle2 = new DepthFirstCycle(graph2);
var depthFirstCycle2Test0 = depthFirstCycle2.HasCycle();
var depthFirstCycle2Test1 = depthFirstCycle2.Cycle();
var depthFirstOrder = new DepthFirstOrder(graph2);
var depthFirstOrderTest0 = depthFirstOrder.PreOrder();
var depthFirstOrderTest1 = depthFirstOrder.PostOrder();
var depthFirstOrderTest2 = depthFirstOrder.ReversePostOrder();
var symbolGraph = new SymbolGraph();
symbolGraph.Insert(new[] { "JFK", "MCO" });
symbolGraph.Insert(new[] { "ORD", "DEN" });
symbolGraph.Insert(new[] { "ORD", "HOU" });
symbolGraph.Insert(new[] { "DFW", "PHX" });
symbolGraph.Insert(new[] { "JFK", "ATL" });
symbolGraph.Insert(new[] { "ORD", "DFW" });
symbolGraph.Insert(new[] { "ORD", "PHX" });
symbolGraph.Insert(new[] { "ATL", "HOU" });
symbolGraph.Insert(new[] { "DEN", "PHX" });
symbolGraph.Insert(new[] { "PHX", "LAX" });
symbolGraph.Insert(new[] { "JFK", "ORD" });
symbolGraph.Insert(new[] { "DEN", "LAS" });
symbolGraph.Insert(new[] { "DFW", "HOU" });
symbolGraph.Insert(new[] { "ORD", "ATL" });
symbolGraph.Insert(new[] { "LAS", "LAX" });
symbolGraph.Insert(new[] { "ATL", "MCO" });
symbolGraph.Insert(new[] { "HOU", "MCO" });
symbolGraph.Insert(new[] { "LAS", "PHX" });
symbolGraph.Build();
var symbolGraphTest0 = symbolGraph.Contains("LAS");
var symbolGraphTest1 = symbolGraph.Contains("MOO");
var symbolGraphTest2 = symbolGraph.Index("LAX");
var symbolGraphTest3 = symbolGraph.Name(symbolGraphTest2);
var symbolGraph2 = new SymbolGraph();
symbolGraph2.Insert(new[] { "Algorithms", "Theoretical CS", "Databases", "Scientific Computing" });
symbolGraph2.Insert(new[] { "Introduction to CS", "Advanced Programming", "Algorithms" });
symbolGraph2.Insert(new[] { "Advanced Programming", "Scientific Computing" });
symbolGraph2.Insert(new[] { "Scientific Computing", "Computational Biology" });
symbolGraph2.Insert(new[] { "Theoretical CS", "Computational Biology", "Artificial Intelligence" });
symbolGraph2.Insert(new[] { "Linear Algebra", "Theoretical CS" });
symbolGraph2.Insert(new[] { "Calculus", "Linear Algebra" });
symbolGraph2.Insert(new[] { "Artificial Intelligence", "Neural Networks", "Robotics", "Machine Learning" });
symbolGraph2.Insert(new[] { "Machine Learning", "Neural Networks" });
symbolGraph2.Build();
var topologicalSort = new TopologicalSort(symbolGraph2.Graph());
var topologicalSorted = new List <string>();
foreach (var item in topologicalSort.Order)
{
topologicalSorted.Add(symbolGraph2.Name(item));
}
var depthFirstComponents = new DepthFirstComponents(graph);
var depthFirstComponentsTest0 = depthFirstComponents.IsStronglyConnected(1, 7);
var depthFirstComponentsTest1 = depthFirstComponents.IsStronglyConnected(0, 2);
var depthFirstComponentsTest2 = depthFirstComponents.IsStronglyConnected(2, 7);
var depthFirstComponentsTest3 = depthFirstComponents.IsStronglyConnected(9, 12);
var depthFirstComponentsTest4 = depthFirstComponents.IsStronglyConnected(6, 8);
var depthFirstComponentsTest5 = depthFirstComponents.IsStronglyConnected(7, 8);
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyCG.txt"); // Prompt
Console.WriteLine("2 - mediumG.txt"); // Prompt
Console.WriteLine("3 - largeG.zip"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
var fieName = string.Empty;
switch (fileNumber)
{
case "1":
fieName = "tinyCG.txt";
break;
case "2":
fieName = "mediumG.txt";
break;
case "3":
fieName = "largeG.zip";
break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fieName}");
var lines = !fieName.EndsWith("zip") ? @in.ReadAllLines() : @in.ReadAllLinesFromZip();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List <EdgeU>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var edge = new EdgeU(ve, we);
edges.Add(edge);
}
lineIterator++;
}
var graph = new Graph(v, e, edges);
if (fileNumber != "3")
{
Console.WriteLine(graph);
}
const int s = 0;
var bfs1 = new BreadthFirstPaths(graph, s);
for (var vi = 0; vi < graph.V; vi++)
{
if (bfs1.HasPathTo(vi))
{
Console.Write($"{s} to {vi}: ");
foreach (int x in bfs1.PathTo(vi))
{
if (x == s)
{
Console.Write(x);
}
else
{
Console.Write($"-{x}");
}
}
Console.WriteLine();
}
else
{
Console.WriteLine($"{s} to {v}: not connected{Environment.NewLine}");
}
if (vi >= 1 && fileNumber == "3")
{
break;
}
}
//Console.WriteLine("------------------------------------------------");
Console.ReadLine();
}
