/// <summary>
/// Get a solution path for the given map.
/// If no solution was found, will return null.
/// </summary>
/// <param name="map">Map to traverse.</param>
/// <returns>Graph node series.</returns>
public IGraphSearchNode<MapFeature> Traverse(Map map, string options = null)
{
IGraphSearchNode<MapFeature> path;
// Move in any direction, even diagonals.
if (options != null &&
String.Equals(options, Movement.Any.ToString(),
StringComparison.CurrentCultureIgnoreCase))
{
path = new BreadthFirstSearch<MapFeature>.Query(map)
.AdjacencyMethod(Graph.GetSurroundingElements)
.FailCondition(PivotAtWalls)
.MatchCondition(IsEndpoint)
.SearchAt(map.StartPosition.X, map.StartPosition.Y);
}
// Can only move up/down/left/right.
else
{
path = new BreadthFirstSearch<MapFeature>.Query(map)
.AdjacencyMethod(Graph.GetAdjacentElements)
.FailCondition(PivotAtWalls)
.MatchCondition(IsEndpoint)
.SearchAt(map.StartPosition.X, map.StartPosition.Y);
}
return path;
}
public int[] FindShortestPath(int fromId, int toId)
{
try {
var graph = _repository.LoadGraph();
var startNode = graph[fromId];
startNode.Layer = 0;
var algorithm = new BreadthFirstSearch();
algorithm.Run(startNode, x => {
foreach (var child in x.GetUnexploredChildren()) {
child.Layer = x.Layer + 1;
if (child.Id == toId) {
algorithm.Stop = true;
}
}
});
return GetPath(fromId, toId, graph);
}
catch (Exception ex) {
_logger.Error("Unexpected exception, cannot calculate the shortest path", ex);
throw;
}
}
public void TraverseGraph(string graphText, string expectedTraversal)
{
var graph = graphText.ToGraph<string, object>();
string traversal = "";
var algo = new BreadthFirstSearch<string, object>();
algo.Run(graph["start"], x => {
traversal += x.Id + ",";
});
traversal = traversal.TrimEnd(new[] { ',' });
Assert.That(traversal, Is.EqualTo(expectedTraversal), "Search path was not correct.");
}
public void CanDoBFS()
{
var graph = new Graph<int>(
Tuple.Create(2, 7),
Tuple.Create(7, 4),
Tuple.Create(4, 6),
Tuple.Create(8, 3),
Tuple.Create(6, 2));
var breadthFirstSearch = new BreadthFirstSearch<int>(graph);
foreach (var vertex in breadthFirstSearch.GetAllReachableVertices(4))
{
Console.WriteLine("Next vertex is {0}", vertex);
}
}
public void BreadthFirstSearch_TextReturnsOutput()
{
BreadthFirstSearch<int> bfs = new BreadthFirstSearch<int>();
using (StringReader sr = new StringReader(myText.bfs_input))
{
int numberOfTestcases = Convert.ToInt32(sr.ReadLine());
int[] nodeEdges = ReadStringIntoNumArray(sr.ReadLine());
int numOfNodes = nodeEdges[0];
int numOfEdges = nodeEdges[1];
Graph<int> myGraph = new Graph<int>();
for (int j = 0; j < numOfNodes; j++)
{
myGraph.AddNode(j + 1);
Console.WriteLine(j+1);
}
GraphNodeDictionary<int> nodes = myGraph.Nodes;
for (int k = 0; k < numOfEdges; k++)
{
Console.WriteLine("at edge " + k);
int[] edgeVertices = ReadStringIntoNumArray(sr.ReadLine());
int from = edgeVertices[0];
int to = edgeVertices[1];
Console.WriteLine(from + " " + to);
myGraph.AddUndirectedEdge(nodes[from], nodes[to], 6);
}
int startIndex = Convert.ToInt32(sr.ReadLine());
GraphNode<int> startNode = nodes[startIndex];
List<int> bfs_distance = bfs.GetDistances(myGraph, startNode);
List<int> distances = new List<int>();
for (int n = 0; n < nodes.Count; n++)
{
Console.WriteLine(n);
distances.Add(nodes[n+1].Distance);
}
string result = String.Join(" ", bfs_distance);
Assert.AreEqual(result, "6 6 6 6 12 6 12 6 12 12 6 6 6 6 6 12 12 6 6 6 6 12 6 12 6 12 6 12 12 12 12 6 12 12 6 12 12 6 12 6 12 6 12 12 6 6 12 6 6 6 6 12 12 12 12 6 6 6 12 6 6 12 12 12 12 12 12 6 6");
}
}
private void outputResults(Graph<Node, Edge> graph, int src, int tgt)
{
SysDbg.Write("\t");
BFS dfs = new BFS(graph, src, tgt);
if (dfs.TargetFound)
{
SysDbg.Write("BFS from " + src + " to " + tgt + ": ");
List<int> path;
dfs.PathToTarget(out path);
foreach (int node in path)
SysDbg.Write(node + " ");
SysDbg.WriteLine("");
}
else
SysDbg.WriteLine("BFS search could not find " + tgt
+ " from " + src + "!");
}
static void Solve(string[] args)
{
int numberOfTestcases = Convert.ToInt32(Console.ReadLine());
BreadthFirstSearch<int> bfs = new BreadthFirstSearch<int>();
for (int i = 0; i < numberOfTestcases; i++)
{
int[] nodeEdges = ReadStringIntoNumArray(Console.ReadLine());
int numOfNodes = nodeEdges[0];
int numOfEdges = nodeEdges[1];
Graph<int> myGraph = new Graph<int>();
for (int j = 0; j < numOfNodes; j++)
{
myGraph.AddNode(j + 1);
}
GraphNodeDictionary<int> nodes = myGraph.Nodes;
for (int k = 0; k < numOfEdges; k++)
{
int[] edgeVertices = ReadStringIntoNumArray(Console.ReadLine());
int from = edgeVertices[0];
int to = edgeVertices[1];
myGraph.AddUndirectedEdge(nodes[from], nodes[to], 6);
}
int startIndex = Convert.ToInt32(Console.ReadLine());
GraphNode<int> startNode = nodes[startIndex];
bfs.GetDistances(myGraph, startNode);
List<int> distances = new List<int>();
for (int n = 0; n < nodes.Count; n++)
{
distances.Add(nodes[n].Distance);
}
string result = String.Join(" ", distances);
Console.WriteLine(result);
}
}
public void BreadthFirstSearch_FourNodesStartNodeOne_Returns661()
{
int numberOfTestcases = 1;
int[] nodes_and_edges = new int[2] { 4, 2 };
int[] firstEdge = new int[2] { 1, 2 };
int[] secondEdge = new int[2] { 1, 3 };
int startNode = 1;
Graph<int> graph = new Graph<int>();
for (int i = 0; i < 4; i++)
{
graph.AddNode(i + 1);
}
GraphNodeDictionary<int> nodes = graph.Nodes;
graph.AddUndirectedEdge(nodes[1], nodes[2], 6);
graph.AddUndirectedEdge(nodes[1], nodes[3], 6);
BreadthFirstSearch<int> bfs = new BreadthFirstSearch<int>();
List<int> distances = bfs.GetDistances(graph, graph.Nodes[startNode]);
string result = String.Join(" ", distances);
Assert.AreEqual("6 6 -1", result);
}
public static void Main(String[] args)
{
#region graph
var g = new OwlerDB();
g["name"] = "Germany";
#endregion
#region cities
var Frankfurt = new Vertex(new Dictionary <string, object>()
{
{ "name", "Frankfurt" }
});
var Mannheim = new Vertex(new Dictionary <string, object>()
{
{ "name", "Mannheim" }
});
var Wuerzburg = new Vertex(new Dictionary <string, object>()
{
{ "name", "Wuerzburg" }
});
var Stuttgart = new Vertex(new Dictionary <string, object>()
{
{ "name", "Stuttgart" }
});
var Karlsruhe = new Vertex(new Dictionary <string, object>()
{
{ "name", "Karlsruhe" }
});
var Erfurt = new Vertex(new Dictionary <string, object>()
{
{ "name", "Erfurt" }
});
var Nuernberg = new Vertex(new Dictionary <string, object>()
{
{ "name", "Nuernberg" }
});
var Kassel = new Vertex(new Dictionary <string, object>()
{
{ "name", "Kassel" }
});
var Augsburg = new Vertex(new Dictionary <string, object>()
{
{ "name", "Augsburg" }
});
var Muenchen = new Vertex(new Dictionary <string, object>()
{
{ "name", "Muenchen" }
});
g.AddVertex(Frankfurt);
g.AddVertex(Mannheim);
g.AddVertex(Wuerzburg);
g.AddVertex(Stuttgart);
g.AddVertex(Karlsruhe);
g.AddVertex(Erfurt);
g.AddVertex(Nuernberg);
g.AddVertex(Kassel);
g.AddVertex(Augsburg);
g.AddVertex(Muenchen);
#endregion
#region roads
g.AddEdge(new Edge(Frankfurt, Mannheim, new Dictionary <string, object>()
{
{ "s", 85 }
}));
g.AddEdge(new Edge(Frankfurt, Wuerzburg, new Dictionary <string, object>()
{
{ "s", 127 }
}));
g.AddEdge(new Edge(Frankfurt, Kassel, new Dictionary <string, object>()
{
{ "s", 172 }
}));
g.AddEdge(new Edge(Mannheim, Karlsruhe, new Dictionary <string, object>()
{
{ "s", 80 }
}));
g.AddEdge(new Edge(Wuerzburg, Erfurt, new Dictionary <string, object>()
{
{ "s", 186 }
}));
g.AddEdge(new Edge(Wuerzburg, Nuernberg, new Dictionary <string, object>()
{
{ "s", 103 }
}));
g.AddEdge(new Edge(Nuernberg, Stuttgart, new Dictionary <string, object>()
{
{ "s", 183 }
}));
g.AddEdge(new Edge(Nuernberg, Muenchen, new Dictionary <string, object>()
{
{ "s", 167 }
}));
g.AddEdge(new Edge(Karlsruhe, Augsburg, new Dictionary <string, object>()
{
{ "s", 250 }
}));
g.AddEdge(new Edge(Augsburg, Muenchen, new Dictionary <string, object>()
{
{ "s", 84 }
}));
g.AddEdge(new Edge(Kassel, Muenchen, new Dictionary <string, object>()
{
{ "s", 502 }
}));
#endregion
foreach (var edge in Frankfurt.OutgoingEdges)
{
Console.WriteLine(edge.Target["name"] + " " + edge["s"] + "km");
}
Console.WriteLine(g.VertexCount);
Console.WriteLine(g.EdgeCount);
var path = BreadthFirstSearch.Search(g, Frankfurt, Muenchen);
foreach (var v in path)
{
Console.WriteLine(v["name"]);
}
Console.ReadKey(true);
}
private static void Main(string[] args)
{
var inputText = File.ReadAllLines(@"../../../input.txt");
field = inputText.Select(x => x.ToCharArray()).ToArray();
rows = field.Length;
columns = field[0].Length;
var allNumbers = field.SelectMany(x => x).Where(char.IsDigit).ToArray();
var numberPositions = new Dictionary <char, Coordinate>();
for (var rowIndex = 0; rowIndex < rows; rowIndex++)
{
for (var colIndex = 0; colIndex < columns; colIndex++)
{
var c = new Coordinate(colIndex, rowIndex);
var content = ContentAt(c);
if (char.IsDigit(content))
{
numberPositions.Add(content, c);
}
}
}
foreach (var position in numberPositions)
{
Console.WriteLine($"Number {position.Key} found at {position.Value}");
}
var bfs = new BreadthFirstSearch <Coordinate, MoveDirection>(new CoordinateIdentical(), GetPossibleMovements,
GetPosition);
var distances = new Dictionary <string, int>();
foreach (var number in numberPositions.Keys)
{
var others = bfs.FindAll(numberPositions[number], coords => ContentAt(coords) > number);
foreach (var other in others)
{
var edge1 = string.Concat(number, ContentAt(other.Target));
var edge2 = string.Concat(ContentAt(other.Target), number);
var edgeLength = other.Length - 1;
distances.Add(edge1, edgeLength);
distances.Add(edge2, edgeLength);
Console.WriteLine($"Edge {edge1} / {edge2} is {edgeLength} long.");
}
}
var allTrips = new Permutations <char>(allNumbers);
var allTripsWithLengths = new Dictionary <string, int>();
foreach (IList <char> trip in allTrips)
{
if (trip[0] != '0')
{
continue;
}
trip.Add('0');
var name = string.Concat(trip);
var length = 0;
foreach (var walk in trip.PairwiseWithOverlap())
{
var edge = string.Concat(walk.Item1, walk.Item2);
length += distances[edge];
}
allTripsWithLengths.Add(name, length);
}
Console.WriteLine();
var min = allTripsWithLengths.OrderBy(x => x.Value).Take(3);
foreach (var trip in min)
{
Console.WriteLine($"Trip {trip.Key} is {trip.Value} long");
}
Console.ReadLine();
}
public void Small_maze_test()
{
var start = new Point(9, 3);
var end = new Point(1, 5);
var maze = @"
%%%%%%%%%%%%%%%%%%%%
%--------------%---%
%-%%-%%-%%-%%-%%-%-%
%--------P-------%-%
%%%%%%%%%%%%%%%%%%-%
%.-----------------%
%%%%%%%%%%%%%%%%%%%%";
Func <Point, char> getCell = GetCell(maze);
Func <Point, IEnumerable <Point> > getNeighbours = GetNeighbours(getCell);
var result = BreadthFirstSearch.Explore(start, getNeighbours);
var path = new List <Point>();
foreach (var item in result)
{
path.Add(item);
if (item == end)
{
break;
}
}
var expected = new[] {
new Point(9, 3),
new Point(10, 3),
new Point(10, 2),
new Point(10, 1),
new Point(11, 1),
new Point(12, 1),
new Point(13, 1),
new Point(14, 1),
new Point(13, 2),
new Point(13, 3),
new Point(14, 3),
new Point(15, 3),
new Point(16, 3),
new Point(16, 2),
new Point(16, 1),
new Point(17, 1),
new Point(18, 1),
new Point(18, 2),
new Point(18, 3),
new Point(18, 4),
new Point(18, 5),
new Point(17, 5),
new Point(16, 5),
new Point(15, 5),
new Point(14, 5),
new Point(13, 5),
new Point(12, 5),
new Point(11, 5),
new Point(10, 5),
new Point(9, 5),
new Point(8, 5),
new Point(7, 5),
new Point(6, 5),
new Point(5, 5),
new Point(4, 5),
new Point(3, 5),
new Point(2, 5),
new Point(1, 5),
};
Assert.That(path, Is.EquivalentTo(expected));
}
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");
}
private void Bfs_FormClosed(object sender, FormClosedEventArgs e)
{
bfs = null;
}
private void pb_Search_Click(object sender, EventArgs e)
{
if (tb_Search.Text.ToString() == "스택(Stack)")
{
stack = new Stack();
stack.FormClosed += Stack_FormClosed;
stack.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "연결리스트(LinkedList)")
{
ll = new LinkedList();
ll.FormClosed += Ll_FormClosed;
ll.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "삽입정렬(InsertSort)")
{
Is = new InsertSort();
Is.FormClosed += Is_FormClosed;
Is.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "선택정렬(SelectionSort)")
{
ss = new SelectionSort();
ss.FormClosed += Ss_FormClosed;
ss.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "이진탐색트리(BinarySearchTree)")
{
bst = new BinarySearchTree();
bst.FormClosed += Bst_FormClosed;
bst.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "큐(Queue)")
{
q = new QUeue();
q.FormClosed += Q_FormClosed;
q.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "쉘정렬(ShellSort)")
{
shellSort = new ShellSort();
shellSort.FormClosed += ShellSort_FormClosed;
shellSort.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "깊이우선탐색(Depth-first search)")
{
dfs = new DepthFirstSearch();
dfs.FormClosed += Dfs_FormClosed;
dfs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "너비우선탐색(Breadth-first search)")
{
bfs = new BreadthFirstSearch();
bfs.FormClosed += Bfs_FormClosed;
bfs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "버블정렬(BubbleSort)")
{
bs = new BubbleSort();
bs.FormClosed += Bs_FormClosed;
bs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "퀵정렬(QuickSort)")
{
qs = new QuickSort();
qs.FormClosed += Qs_FormClosed;
qs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "힙정렬(HeapSort)")
{
hs = new HeapSort();
hs.FormClosed += Hs_FormClosed;
hs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "기수정렬(RadixSort)")
{
rs = new RadixSort();
rs.FormClosed += Rs_FormClosed;
rs.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "버킷정렬(BucketSort)")
{
bucketsort = new BucketSort();
bucketsort.FormClosed += Bucketsort_FormClosed;
bucketsort.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "다익스트라알고리즘(Dijkstra algorithm)")
{
dijkstra = new Dijkstra();
dijkstra.FormClosed += Dijkstra_FormClosed;
dijkstra.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "프림알고리즘(Prim's algorithm)")
{
prim = new Prim();
prim.FormClosed += Prim_FormClosed;
prim.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "머지정렬(MergeSort)")
{
mergesort = new MergeSort();
mergesort.FormClosed += Mergesort_FormClosed;
mergesort.Show();
this.Close();
}
if (tb_Search.Text.ToString() == "카운팅정렬(CountingSort)")
{
cs = new CountingSort();
cs.FormClosed += Cs_FormClosed;
cs.Show();
this.Close();
}
}
public bool RunOperation(int choice)
{
switch (choice)
{
case 1:
var t1 = new FactorialCalculator();
t1.Run();
break;
case 2:
var t2 = new TelephoneDirectorySearch();
t2.Run();
break;
case 3:
var t3 = new ArrayIsSorted();
t3.Run();
break;
case 4:
var t4 = new MergeSort();
t4.Run();
break;
case 5:
var t5 = new BubbleSort();
t5.Run();
break;
case 6:
var t6 = new BruteForcePasswordGenerator.BruteForcePasswordGenerator();
t6.Run();
break;
case 7:
var t7 = new BruteForcePasswordGeneratorCSharp.BruteForcePasswordGenerator();
t7.Run();
break;
case 8:
var t8 = new QuickSort();
t8.Run();
break;
case 9:
var t9 = new DepthFirstSearch();
t9.Run();
break;
case 10:
var t10 = new BreadthFirstSearch();
t10.Run();
break;
// Quit case
case 0:
return(true);
// Invalid choice case
default:
Console.WriteLine("\nInvalid menu choice selected");
break;
}
return(false);
}
public ChessboardHopper(Chessboard chessboard)
{
this._chessboard = chessboard;
this._breadthFirstSearchSolver = new BreadthFirstSearch();
}
public static void UninformedAlgorithms()
{
Console.WriteLine("Welcome\nARTIFICIAL INTELLIGENCE SEARCH ALGORITHMS");
ShowOptions();
var input = Console.ReadLine();
int res = 1;
while (int.TryParse(input, out res) == false)
{
ShowOptions();
input = Console.ReadLine();
}
Node <string> startNode = null;
Node <string> goalNode = null;
switch (Convert.ToInt32(input))
{
case 1:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("BREADTH FIRST SEARCH IMPLEMENTATION------------");
var bfs = new BreadthFirstSearch <string>(goalNode, startNode);
bfs.Search();
}
break;
case 2:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("DEPTH FIRST SEARCH IMPLEMENTATION------------");
var dfs = new DepthFirstSearch <string>(goalNode, startNode);
dfs.Search();
}
break;
case 3:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("\nEnd\n");
Console.WriteLine("ITERATIVE DEEPENING SEARCH IMPLEMENTATION------------");
var ids = new IterativeDeepingSearch <string>(goalNode, startNode);
ids.Search();
}
break;
case 4:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("DEPTH LIMITED SEARCH IMPLEMENTATION------------");
Console.Write("Enter limit to search: ");
var limit = int.Parse(Console.ReadLine());
var dls = new DepthLimitedSearch <string>(goalNode, startNode, limit);
dls.Search();
}
break;
case 5:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("Enter the cost for the nodes");
foreach (var node in Nodes)
{
Console.Write($"Enter cost for node: {node.NodeName}: ");
node.Cost = double.Parse(Console.ReadLine());
}
Console.WriteLine("UNIFORM COST SEARCH IMPLEMENTATION------------");
var ucs = new UniformCostSearch <string>(goalNode, startNode);
ucs.Search();
}
break;
case 6:
{
startNode = GetRootNode();
goalNode = GetGoalNode();
Console.WriteLine("BIDIRECTIONAL SEARCH IMPLEMENTATION------------");
var bidi = new BidirectionalSearch <string>(goalNode, startNode);
bidi.Search();
}
break;
default:
ShowOptions();
break;
}
}
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);
}
internal BreadthFirstSearch(Node value, BreadthFirstSearch <Node>?previous = null)
: base(value: value, previous: previous)
{
}
private BaseSearchAlgo GetAlgorithm()
{
BaseSearchAlgo algo = null;
switch (m_searchAlgo)
{
case SearchAlgo.A_Star:
algo = new AStar(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.Theta_Star:
algo = new ThetaStar(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.LazyTheta_Star:
algo = new LazyThetaStar(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.BestFirstSearch:
algo = new BestFirstSearch(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.BreadthFirstSearch:
algo = new BreadthFirstSearch(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.DijkstraSearch:
algo = new DijkstraSearch(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.JPS:
algo = new JumpPointSearch(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.JPSPlus:
algo = new JPSPlus(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
case SearchAlgo.BiA_Star:
algo = new BiAStar(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime);
break;
#region Incremental
case SearchAlgo.D_Star:
algo = new DStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.FocussedD_Star:
algo = new FocussedDStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.LPA_Star:
algo = new LPAStar(m_startNode, m_goalNode, m_nodes, m_showTime);
//algo = new LPAStar_Optimized(m_startNode, m_endNode, m_nodes, m_showTime);
break;
case SearchAlgo.DstarLite:
algo = new DStarLite(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.Path_AA_Star:
algo = new Path_AAStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.Tree_AA_Star:
algo = new Tree_AAStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
#endregion
#region Moving Target
case SearchAlgo.GAA_Star:
algo = new GAAStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.GFRA_Star:
algo = new GFRAStar(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
case SearchAlgo.MT_DstarLite:
algo = new MT_DStarLite(m_startNode, m_goalNode, m_nodes, m_showTime);
break;
#endregion
case SearchAlgo.AnnotatedA_Star:
algo = new AnnotatedAStar(m_startNode, m_goalNode, m_nodes, m_weight, m_showTime, m_unitSize);
break;
default:
Debug.LogError($"No code for SearchAlgo={m_searchAlgo}");
break;
}
return(algo);
}
