private void btnChayTuDong_Click(object sender, EventArgs e)
{
if (Check())
{
// kiểm tra time delay
int timeDelay = 0;
try
{
timeDelay = Int32.Parse(txtDelay.Text);
if (timeDelay < 0)
{
MessageBox.Show("Time delay phải là số nguyên dương", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
catch
{
MessageBox.Show("Time delay phải là số nguyên dương","Thông báo",MessageBoxButtons.OK,MessageBoxIcon.Error);
return;
}
btnTamDung.Enabled = true;
btnKetThuc.Enabled = true;
btnBatDauChayTungBuoc.Enabled = false;
groupSetting.Enabled = false;
listDoThi = DFS.Run(Data.Data.graph_DFS, (int)cbxDinhXuatPhat.SelectedValue, (int) cbxDinhKetThuc.SelectedValue);
index = 0;
timer.Enabled = true;
timer.Interval = timeDelay;
timer.Start();
return;
}
}
private void btnBatDauChayTungBuoc_Click(object sender, EventArgs e)
{
if (btnBatDauChayTungBuoc.Text == "Bắt đầu chạy từng bước")
{
if (Check())
{
listDoThi = DFS.Run(Data.Data.graph_DFS, (int)cbxDinhXuatPhat.SelectedValue, (int)cbxDinhKetThuc.SelectedValue);
index = 0;
HienThiDoThi();
btnChayTuDong.Enabled = false;
btnPrev.Enabled = true;
btnNext.Enabled = true;
btnStart.Enabled = true;
btnEnd.Enabled = true;
groupSetting.Enabled = false;
btnBatDauChayTungBuoc.Text = "Kết thúc chạy từng bước";
}
return;
}
if (btnBatDauChayTungBuoc.Text == "Kết thúc chạy từng bước")
{
btnBatDauChayTungBuoc.Text = "Bắt đầu chạy từng bước";
btnChayTuDong.Enabled = true;
btnPrev.Enabled = false;
btnNext.Enabled = false;
btnStart.Enabled = false;
btnEnd.Enabled = false;
groupSetting.Enabled = true;
return;
}
}
static void Main()
{
Console.WriteAscii("Light up solver", Color.Yellow);
Console.WriteLine("Authors: Michał Bator, Agnieszka Sobota", Color.LightYellow);
Console.WriteLine();
Console.WriteLine("Starting session:");
Console.WriteLine("Provide a path to the board file: ");
var path = Console.ReadLine();
if (!File.Exists(path))
{
Console.WriteLine("Provided path does not lead to any file. Exiting.", Color.Red);
Console.ReadKey();
return;
}
var board = new Board(path);
Console.WriteLine("====================================");
Console.WriteLine();
Console.WriteLine("\tBoard loaded successfully.");
Console.WriteLine();
var DFSbox = new DFS(board);
var AStarBox = new AStar(board);
Task.Run(() => DFSbox.Perform());
Task.Run(() => AStarBox.Perform());
Console.ReadKey();
}
static void Main()
{
var n1 = new Node("n1");
var n2 = new Node("n2");
var n3 = new Node("n3");
var n4 = new Node("n4");
var n5 = new Node("n5");
var n6 = new Node("n6");
var n7 = new Node("n7");
var n8 = new Node("n8");
var n9 = new Node("n9");
var n10 = new Node("n10");
n1.AddChildren(n2).AddChildren(n3).AddChildren(n4);
n2.AddChildren(n5);
n3.AddChildren(n5);
n4.AddChildren(n6);
n5.AddChildren(n7);
n6.AddChildren(n8);
n6.AddChildren(n9);
n7.AddChildren(n10);
n8.AddChildren(n10);
n9.AddChildren(n10);
var fullPath = DFS.FindFullPath(n6, n10);
foreach (var item in fullPath)
{
Console.Write($"{item.Name} ");
}
Console.ReadKey();
}
void SetTarget_Local(MapManager.NavPoint point)
{
moveRode = null;
objSign.SetActive(true);
objSign.transform.position = new Vector3(point.col, 0, point.row);
System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
switch (navType)
{
case NavLibrary.Algorithm.DFS:
moveRode = DFS.Navigation(currentPoint, point);
break;
case NavLibrary.Algorithm.BFS:
moveRode = BFS.Navigation(currentPoint, point);
break;
case NavLibrary.Algorithm.A_Star:
moveRode = A_Star.Navigation(currentPoint, point);
break;
default:
moveRode = null;
break;
}
stopWatch.Stop();
MainView.Instance.RefreshInfo(point.row, point.col, stopWatch.Elapsed.TotalMilliseconds);
Debug.Log("Cost Time: " + stopWatch.Elapsed.TotalMilliseconds);
if (!IsMoving)
{
MoveToNextPoint_Local();
}
}
private void CreateWall(Wall wallEntity)
{
Wall randomWall;
if (wallEntity.Row >= 0 && wallEntity.Column >= 0)
{
randomWall = wallEntity;
}
else
{
var notActiveWalls = GetNotActiveWalls();
var availableWalls = notActiveWalls.Where((wall) => {
var wallsOnPosition = GetWallsOnPosition(wall.Row, wall.Column);
var nextPos = PositionHelper.GetNextPosition(wall.Row, wall.Column, wall.Direction);
var wallsOnNextPosition = GetWallsOnPosition(nextPos.Row, nextPos.Column);
return(wallsOnPosition.Count < 2 && wallsOnNextPosition.Count < 2 &&
DFS.IsConnectedWithoutEdge(_graph, wall.Row, wall.Column, nextPos.Row, nextPos.Column));
}).ToList();
randomWall = availableWalls.RandomElement();
}
if (randomWall == null)
{
return;
}
CloseWall(wallEntity, randomWall);
var nextPosition = PositionHelper.GetNextPosition(randomWall.Row, randomWall.Column, randomWall.Direction);
_graph.RemoveEdge(randomWall.Row, randomWall.Column, nextPosition.Row, nextPosition.Column);
}
public static void Main(string[] args)
{
var dfs = new DFS();
dfs.TestDFS();
// var bfs = new BFS();
// bfs.TestBFS();
// var fibo = new Fibonacci();
// fibo.TestFibonacci();
// var floodFill = new FloodFill();
// floodFill.TestFloodFillDFS();
// floodFill.TestGraphTraversalBlockedSpacesAnd4MovesDFS();
// floodFill.TestShortestPathTraversal();
var greedy = new GreedyAlgo();
// greedy.ComputeMaxTasksCompleted();
greedy.ComputeMaxPrioritizedTasksCompleted();
// DicesSumModel diceSumModel = new DicesSumModel();
// diceSumModel.TestProbabilityDiceSum();
// DateTimeModel dateTimeModel = new DateTimeModel();
// dateTimeModel.TestMultipleDateTimeDiff();
// Build webhost
// BuildWebHost(args).Run();
}
/// <summary>
/// Compares the solvers.
/// </summary>
/// <param name="row">The row.</param>
/// <param name="col">The col.</param>
public static void CompareSolvers(int row, int col)
{
// create maze
DFSMazeGenerator myMazeGen = new DFSMazeGenerator();
Maze maze = myMazeGen.Generate(row, col);
Console.WriteLine(maze);
ObjectAdapter mazeAdapter = new ObjectAdapter(maze);
// BFS solution
ISearcher <Position> sbfs = new BFS <Position>();
sbfs.Search(mazeAdapter);
// print num of stages
Console.WriteLine("BFS: " + sbfs.GetNumberOfNodesEvaluated());
// DFS solution
ISearcher <Position> sdfs = new DFS <Position>();
sdfs.Search(mazeAdapter);
// print num of stages
Console.WriteLine("DFS: " + sdfs.GetNumberOfNodesEvaluated());
}
/// <summary>
/// Generates a thread that solves the maze 'mazeName'
/// </summary>
/// <param name="mazeName">maze name</param>
/// <param name="algorithm">algorithm to solve with</param>
public void solveMaze(string mazeName, string algorithm)
{
ISearchingAlgorithm searching = null;
if ("BFS" == algorithm)
{
searching = new BFS();
}
else if ("DFS" == algorithm)
{
searching = new DFS();
}
else
{
m_controller.errOutput("wrong argument inserted for <algorithm>, Algorithm options are BFS/DFS\n");
return;
}
m_controller.Output("Solving maze...\n");
Thread thread = new Thread(() => solve(searching, mazeName));
m_threads.Add(thread);
thread.Start();
}
private void buttonRecomen_Click(object sender, EventArgs e)
{
if (dropdownRecommend.Text != "")
{
Node person = Parser.result.persons.Find(p => p.name.Equals(dropdownRecommend.Text));
if (this.DFSbuttonRekomen.Checked)
{
string rekomen = DFS.friendRecommendation(Parser.result, person);
this.textRecomens.Text = rekomen;
}
else if (this.BFSbuttonRekomen.Checked)
{
string rekomen = BFS.friendRecommendation(Parser.result, person);
this.textRecomens.Text = rekomen;
}
else
{
this.textRecomens.Text = "";
MessageBox.Show("Anda harus memilih algoritma pencarian");
}
}
else
{
MessageBox.Show("Anda harus mengisi dropdown");
}
}
public SolutionDetails <Direction> SolveMaze(string name, int algo)
{
SolutionDetails <Direction> sol_det;
Searcher <Position, Direction> s;
if (Sol.TryGetValue(name, out sol_det))
{
return(sol_det);
}
Maze maze;
Mazes.TryGetValue(name, out maze);
if (maze == null)
{
return(null);
}
if (algo == BFS)
{
s = new BestFS();
}
else
{
s = new DFS();
}
sol_det = s.search(new SearchableMaze(maze));
//sol_det = new SolutionDetails<Direction>(s.search(new SearchableMaze(maze)), s.getNumberOfNodesEvaluated());
Sol.Add(name, sol_det);
return(sol_det);
}
private static void DisplayEdgeProperties <T>(Graph <T> graph) where T : IComparable <T>
{
DFS <T> dfs = new DFS <T>(graph);
dfs.EdgeTraversed += new EventHandler <EdgeEventArgs <T> >(GraphEventFunctions.DisplayEdgeProperties);
dfs.Compute();
}
/// <summary>
/// solving a private maze
/// if the solution for this maze already exists it returns it
/// </summary>
/// <param name="name"></param>
/// <param name="algorithm"></param>
/// <returns></returns>
public string SolveMaze(string name, int algorithm)
{
Maze m = privateMazeDict[name];
MazeAdapter <Position> maze = new MazeAdapter <Position>(m);
Searcher <Position> searcher;
Solution <Position> sol;
if (!privateSolDict.Keys.Contains(name))
{
if (algorithm == 0)
{
searcher = new BFS <Position>();
CostComparator <Position> compare = new CostComparator <Position>();
sol = searcher.Search(maze, compare);
}
else
{
searcher = new DFS <Position>();
sol = searcher.Search(maze);
}
privateSolDict.Add(name, sol);
}
else
{
sol = privateSolDict[name];
}
string stringSolution = maze.ToSolution(sol);
int numberOfNodesevaluated = sol.EvaluatedNodes;
stringSolution += " ";
stringSolution += numberOfNodesevaluated;
return(stringSolution);
}
public void Test_Search()
{
// arrange
var root = new Node(0);
var one = new Node(1);
var two = new Node(2);
var three = new Node(3);
var four = new Node(4);
var five = new Node(5);
root.Children.Add(one);
root.Children.Add(four);
root.Children.Add(five);
one.Children.Add(four);
one.Children.Add(three);
three.Children.Add(four);
three.Children.Add(two);
two.Children.Add(one);
// act
var actual = new DFS().Search(root, new List <int>());
// assert
var expected = new List <int> {
0, 1, 4, 3, 2, 5
};
Assert.That(actual, Is.EqualTo(expected));
}
public override void Update()
{
if (Input.KeyPressed(Key.D))
{
var search = new DFS <NearbyTiles, MoveAction>(_graphSearch);
Game.SwitchScene(new LabyrinthScene <NearbyTiles, MoveAction>(_problem, search, _graphSearch));
}
else if (Input.KeyPressed(Key.B))
{
var graphSearchBFS = new GraphSearchBFS <NearbyTiles, MoveAction>();
var search = new BFS <NearbyTiles, MoveAction>(graphSearchBFS);
Game.SwitchScene(new LabyrinthScene <NearbyTiles, MoveAction>(_problem, search, graphSearchBFS));
}
else if (Input.KeyPressed(Key.G))
{
var search = new GreedySearch <NearbyTiles, MoveAction>(_graphSearch,
node => Math.Abs(21 - node.State.Center.X) + Math.Abs(20 - node.State.Center.Y));
Game.SwitchScene(new LabyrinthScene <NearbyTiles, MoveAction>(_problem, search, _graphSearch));
}
else if (Input.KeyPressed(Key.A))
{
var search = new AStarSearch <NearbyTiles, MoveAction>(_graphSearch,
node => Math.Abs(21 - node.State.Center.X) + Math.Abs(20 - node.State.Center.Y));
Game.SwitchScene(new LabyrinthScene <NearbyTiles, MoveAction>(_problem, search, _graphSearch));
}
}
/// <summary>
/// Solves the maze.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="algorithm">The algorithm.</param>
/// <returns></returns>
public /*Solution<Position>*/ List <string> SolveMaze(string name, int algorithm)
{
SingleGame game = cash.GetSingleGame(name);
if (game != null)
{
//Solution<Position> solution = cash.GetSolution(name);
/*Solution<Position> solution = game.Solution;
* if (!(solution == null))
* {
* return solution;
* }*/
//Maze maze = cash.GetMaze(name);
Maze maze = game.Maze;
ISearcher <Position> searcher = null;
if (algorithm == 0)
{
searcher = new BFS <Position>();
}
else if (algorithm == 1)
{
searcher = new DFS <Position>();
}
MazeAdapter <Position> mazeAdapter = new MazeAdapter <Position>(maze);
Solution <Position> solution = searcher.Search(mazeAdapter);
//cash.AddSolution(name, solution);
//game.Solution = solution;
return(this.GetSolutionString(solution.List)); //solution;
}
return(null);
}
/// <summary>
/// Solves the maze.
/// </summary>
/// <param name="maze">The maze.</param>
/// <returns>a list of mazePositions that represent the path
/// that completed the given Maze
/// </returns>
internal List <MazePosition> SolveMaze(IMaze maze)
{
List <MazePosition> solution = new List <MazePosition>();
PathSearchResult <MazePosition> result;
switch (this.way)
{
case WayToSolve.BFS:
result = new BFS <MazePosition>().Search(new SearchableMaze(maze));
break;
case WayToSolve.DFS:
result = new DFS <MazePosition>().Search(new SearchableMaze(maze));
break;
default:
return(null);
}
// from States List to MazePositions List
for (int i = 0; i < result.GetPathLenght(); i++)
{
solution.Add(result[i].TState);
}
return(solution);
}
/// <summary>
/// Solves the maze.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="typeAlgo">The type algo.</param>
/// <returns></returns>
public static SolveInfo SolveMaze(string name, string typeAlgo)
{
Maze maze = singleplayerMazeList[name];
MazeAdapter mazeSearchable = new MazeAdapter(maze); // Isearchable
var temp = new CompareStates <Position>();
Solution <Position> solution = null;
int nodesEvaluated = 0;
if (solutionsList.ContainsKey(maze))
{
return(solutionsList[maze]);
}
// find solution of the maze:
switch (typeAlgo)
{
case "0":
BFS <Position> bfs = new BFS <Position>(temp);
solution = bfs.Search(mazeSearchable);
nodesEvaluated = bfs.GetNumberOfNodesEvaluated();
break;
case "1":
DFS <Position> dfs = new DFS <Position>(temp);
solution = dfs.Search(mazeSearchable);
nodesEvaluated = dfs.GetNumberOfNodesEvaluated();
break;
}
SolveInfo solveInfo = new SolveInfo(nodesEvaluated, solution);
// add the solution to the solutions dictionary
solutionsList.Add(maze, solveInfo);
return(solveInfo);
}
/// <summary>
/// Solve Maze - Solves the given maze with a given
/// solving algorithm - BFS/DFS
/// </summary>
/// <param name="mazeName">Maze name</param>
/// <param name="solvingAlgorithm">Solving algorithm - BFS/DFS</param>
public void solveMaze(string mazeName, string solvingAlgorithm)
{
ISearchingAlgorithm searchingAlgorithm = null;
if (solvingAlgorithm == "DFS")
{
searchingAlgorithm = new DFS();
}
else if (solvingAlgorithm == "BFS")
{
searchingAlgorithm = new BFS();
}
else
{
return;
}
var resetEvent = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(new WaitCallback((state) =>
{
solve(searchingAlgorithm, mazeName);
resetEvent.Set();
}));
resetEvent.WaitOne();
}
/// <summary>
/// Solves the specified maze.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="typeOfSolve">The type of solve.</param>
/// <returns>the solve of the maze</returns>
/// <exception cref="System.Exception">This maze does not exist - " + name</exception>
public MazeSolution Solve(string name, int typeOfSolve)
{
if (solutionMazes.ContainsKey(name))
{
return(solutionMazes[name]);
}
if (mazes.ContainsKey(name))
{
Maze maze = mazes[name];
ObjectAdapter adapter = new ObjectAdapter(maze);
BFS <Position, int> bfs = new BFS <Position, int>();
DFS <Position, int> dfs = new DFS <Position, int>();
switch (typeOfSolve)
{
case 0:
return(ConvertSolution(bfs.Search(adapter), maze.Name));
case 1:
return(ConvertSolution(dfs.Search(adapter), maze.Name));
default:
throw new Exception("This search type does not exist - " + typeOfSolve);
}
}
throw new Exception("This maze does not exist - " + name);
}
/// <summary>
/// Compares BFS and DFS solvers.
/// </summary>
public static void CompareSolvers(Maze maze)
{
var searchableMaze = new MazeAdapter(maze);
int dfsNodesEvaluated, bfsNodesEvaluated;
Solution <Position> dfsSolution, bfsSolution;
Searcher <Position> searcher = new BFS <Position>(new CostComperator <Position>());
bfsSolution = searcher.Search(searchableMaze);
bfsNodesEvaluated = searcher.GetNumberOfNodesEvaluated();
searcher = new DFS <Position>();
dfsSolution = searcher.Search(searchableMaze);
dfsNodesEvaluated = searcher.GetNumberOfNodesEvaluated();
bool isBfsBetter = dfsNodesEvaluated > bfsNodesEvaluated;
Console.WriteLine("Better solution was found by {0} ({1} vs. {2} nodes evaluated)",
isBfsBetter ? "BFS" : "DFS",
isBfsBetter ? bfsNodesEvaluated : dfsNodesEvaluated,
isBfsBetter ? dfsNodesEvaluated : bfsNodesEvaluated);
var drawer = new MazeDrawer();
drawer.DrawMaze(searchableMaze, isBfsBetter ? bfsSolution:dfsSolution);
}
/// <summary>
/// Defines the entry point of the application.
/// </summary>
/// <param name="args">The arguments.</param>
static void Main(string[] args)
{
//generate the maze.
DFSMazeGenerator mazeGenerator = new DFSMazeGenerator();
Maze maze = mazeGenerator.Generate(30, 30);
//adapt the maze.
SearchableMazeAdapter searchableMaze = new SearchableMazeAdapter(maze);
//printing the maze.
Console.Write(searchableMaze.MyMaze.ToString());
Solution <Position> BFSSolution;
Solution <Position> DFSSolution;
//solving by BFS.
ISearcher <Position> searcher = new BFS <Position>();
BFSSolution = searcher.Search(searchableMaze);
BFSSolution.Name = searchableMaze.MyMaze.Name;
searchableMaze.Clean();
//solving by DFS.
searcher = new DFS <Position>();
DFSSolution = searcher.Search(searchableMaze);
DFSSolution.Name = searchableMaze.MyMaze.Name;
//printing the solutions.
Console.WriteLine(BFSSolution.EvaluatedNodes);
Console.WriteLine(DFSSolution.EvaluatedNodes);
}
static void Main(string[] args)
{
Console.WriteLine("----------------------START ALGORITHM TESTS----------------------");
SelectionSort.RunTests();
InsertionSort.RunTests();
Factorial.RunTests();
Palindrome.RunTests();
Recursion.RunTests();
MergeSort.RunTests();
QuickSort.RunTests();
BreadthFirstSearch.RunTests();
Console.WriteLine("----------------------END ALGORITHM TESTS----------------------");
Console.WriteLine("----------------------START PATTERN TESTS----------------------");
BFS.RunTests();
DFS.RunTests();
SlidingWindow.RunTests();
TwoPointers.RunTests();
FastSlowPointers.RunTests();
MergeIntervals.RunTests();
Console.WriteLine("----------------------END PATTERN TESTS----------------------");
}
private static void AddFilterToEdge <T>(Graph <T> G) where T : IComparable <T>
{
DFS <T> dfs = new DFS <T>(G);
dfs.EdgeTraversed += new EventHandler <EdgeEventArgs <T> >(GraphEventFunctions.AddFilterToEdge <T>);
dfs.Compute();
}
public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
ISolver solver = null;
if (request.Solver == "BFS")
{
solver = new BFS();
}
if (request.Solver == "DFS")
{
solver = new DFS();
}
if (request.Solver == "Dijkstra")
{
if (request.Problem == "Time")
{
solver = new DijkstraTime();
}
if (request.Problem == "Cost")
{
solver = new DijkstraCost();
}
}
if (solver != null)
{
problem.Accept(solver);
return(problem.Results);
}
Console.WriteLine("Pick Solver failed");
return(null);
}
public DFSAgent(List <string> log)
{
//Setup the DStar Search
Plan = new Stack <Action>();
Plan.Push(new Action());
DSearch = new DFS(log);
}
public ActionResult ShowRecom(RecoomendSuperclass.Percept percept)
{
c2T = new ConvertToText();
TreeNode treeNode = c2T.RetrieveTree();
accomodationSuper = new StudentAccomodationSuper();
DFS dFS = new DFS();
RecoomendSuperclass.Percept percepts = new RecoomendSuperclass.Percept();
percepts.Incomegroup = percept.Incomegroup;
percepts.area = percept.area;
List <string> recommendations = dFS.IterativeDeepeningSearch(treeNode, percepts, 3, 1);
if (recommendations != null)
{
GetRecommendations(recommendations);
//accomodationSuper.overalRecommendations = studentAccomodation;
TempData["nullOverall"] = false;
}
else
{
TempData["nullOverall"] = true;
}
//List<string> recommendations_safety = dFS.IterativeDeepeningSearch(treeNode, percepts, 3, 2);
//if (recommendations_safety != null)
//{
// GetURecommendations(recommendations_safety);
// //accomodationSuper.basedOnSafety = studentAccomodation;
//}
//else
//{
// TempData["nullSafety"] = true;
//}
List <string> recommendations_sentiment = dFS.IterativeDeepeningSearch(treeNode, percepts, 3, 3);
if (recommendations_sentiment != null)
{
GetTRecommendations(recommendations_sentiment);
// accomodationSuper.basedOnsentiment = studentAccomodation;
TempData["nullSentiment"] = false;
}
else
{
TempData["nullSentiment"] = true;
}
if (accomodationSuper != null)
{
Session["RecommendationRating"] = accomodationSuper;
return(RedirectToAction("ShowRecommendations", "Recommend"));
}
return(View());
}
public void TestDFS()
{
// DFS constructor
Console.WriteLine("\n========== Test: DFS ==========");
var dfs = new DFS <string>();
// FindPath() with tinyDG.txt
Console.WriteLine("\n========== FindPath() with tinyDG.txt ==========");
Console.WriteLine("\nGraph:");
Digraph <int> intGraph = TestGraphLoader.LoadGraph(@"../../../StudyGroupFinder/Data/tinyDG.txt");
Console.Write(intGraph);
Console.WriteLine("Verify at http://algs4.cs.princeton.edu/42digraph/Digraph.java.html");
Console.WriteLine("\nPaths:");
var dfsInt = new DFS <int>();
foreach (Node <int> node in intGraph.Nodes.Values)
{
Node <int> n = intGraph.Nodes["3"];
// HACK: Add source-to-source path
Path p = n == node ? new Path(node.ToString()) : dfsInt.FindPath(intGraph, n, n2 => intGraph.Nodes[n2.ToString()] == node);
Console.WriteLine($"3 to {node.ToString()} ({p.Count - 1}): " + p.ToString());
}
Console.WriteLine("Verify at http://algs4.cs.princeton.edu/42digraph/DepthFirstDirectedPaths.java.html");
// TEST: Add more verified DFS test samples
}
/// <summary>
/// Solves the specified maze.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="algorithm">The algorithm.</param>
/// <returns>
/// solves the maze and returns the solution
/// </returns>
/// <exception cref="System.Exception">Failed at Solve function in model class</exception>
public Solution <Position> Solve(string name, Algorithm algorithm)
{
Solution <MazeLib.Position> sol;
MazeAdapter mazeAdapter = new MazeAdapter(GenerateMazeModel.mazes[name]);
// if the maze is exists
switch (algorithm)
{
case Algorithm.BFS:
{
WeightForEdges <MazeLib.Position> we = new WeightsForShortestWay <MazeLib.Position>();
ISearcher <Position> bfs = new BFS <MazeLib.Position>(we);
// solve the maze with bfs.
sol = bfs.Search(mazeAdapter);
}
break;
case Algorithm.DFS:
{
ISearcher <Position> dfs = new DFS <Position>();
// solves the maze with dfs.
sol = dfs.Search(mazeAdapter);
} break;
default:
return(null);
}
return(sol);
}
/**
* 无向图测试
*/
private void TestCycleGraph()
{
DFS dfs = new DFS();
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
Node d = new Node("D");
Node e = new Node("E");
Node f = new Node("F");
Node g = new Node("G");
Node h = new Node("H");
dfs.AddTwoWayNodes(a, b);
dfs.AddTwoWayNodes(b, c);
dfs.AddTwoWayNodes(c, d);
dfs.AddTwoWayNodes(d, a);
dfs.AddTwoWayNodes(d, g);
dfs.AddTwoWayNodes(a, e);
dfs.AddTwoWayNodes(e, b);
dfs.AddTwoWayNodes(a, f);
dfs.AddTwoWayNodes(b, f);
dfs.AddTwoWayNodes(b, h);
dfs.SetHeadNode(a);
dfs.FindCycles();
}
public void TestGraphAlgorithms()
{
var bfs = new BFS<char>(_graph);
var path1 = bfs.GetPath('A', 'E');
CollectionAssert.AreEqual(path1, new char[] { 'A', 'D', 'E' });
var dfs = new DFS<char>(_graph);
var path2 = dfs.GetPath('A', 'E');
CollectionAssert.AreEqual(path2, new char[] { 'A', 'D', 'E' });
}
// Use this for initialization
void Start()
{
gc = GameObject.FindWithTag("GameController").GetComponent<GameController>();
//cache this for later
firstPoint = startPoint.startingNavPoint;
dfs = new DFS(firstPoint);
//pops the top off the stack which is just the first point
nextPoint = dfs.GetNextNavPoint();
//put us at the start point if we're not
if (Vector3.Distance(transform.position, nextPoint.position) > 0.05f)
transform.position = nextPoint.position;
//find our actual next point
nextPoint = dfs.GetNextNavPoint();
agent = GetComponent<NavMeshAgent>();
agent.updateRotation = false;
SetDestination(nextPoint.position);
foundTribute = false;
}
static void Main(string[] args)
{
string[] inputs;
inputs = Console.ReadLine().Split(' ');
int W = int.Parse(inputs[0]); // number of columns.
int H = int.Parse(inputs[1]); // number of rows.
var map = new List<int[]>();
for (int i = 0; i < H; i++)
{
string LINE = Console.ReadLine(); // represents a line in the grid and contains W integers. Each integer represents one room of a given type.
map.Add(LINE.Split(' ').Select(x => int.Parse(x)).ToArray());
}
int EX = int.Parse(Console.ReadLine()); // the coordinate along the X axis of the exit (not useful for this first mission, but must be read).
var exit = new Point(EX, H-1, Direction.TOP);
var dfs = new DFS(map);
// game loop
while (true)
{
inputs = Console.ReadLine().Split(' ');
int XI = int.Parse(inputs[0]);
int YI = int.Parse(inputs[1]);
string POSI = inputs[2];
var indy = new Point(XI, YI, directionOf(POSI));
int R = int.Parse(Console.ReadLine()); // the number of rocks currently in the grid.
var rocks = new Point[R];
for (int i = 0; i < R; i++)
{
inputs = Console.ReadLine().Split(' ');
int XR = int.Parse(inputs[0]);
int YR = int.Parse(inputs[1]);
string POSR = inputs[2];
rocks[i] = new Point(XR, YR, directionOf(POSR));
}
//TODO: Add rocks to DFS
Console.Error.WriteLine("Indy is at " + indy + " from the " + indy.Position + " which is tile #" + dfs.RoomTypeAt(indy));
var path = dfs.To(indy, exit, rocks);
Console.WriteLine(path);
if (path != "WAIT")
{
var s = path.Split(' ');
var pos = new Point(int.Parse(s[0]), int.Parse(s[1]), directionOf(s[2]));
var oldType = dfs.RoomTypeAt(pos);
dfs.Rotate(pos, 4 - (int)pos.Position);
Console.Error.WriteLine("Storing change of tile at " + pos + " from a #" + oldType + " to a #" + dfs.RoomTypeAt(pos));
}
else
{
Console.Error.WriteLine("Indy waited");
}
}
}
