Пример #1
0
        private IGraph <string> ReadDirectedGraphFromString(string graphString)
        {
            var graph = new GraphAdjList <string>();
            var lines = graphString.Split(Environment.NewLine).Where(s => !string.IsNullOrEmpty(s)).ToList();

            foreach (var line in lines)
            {
                string[]        strings = line.Split("-");
                Vertex <string> v       = new Vertex <string> {
                    Value = strings[0]
                };
                graph.Vertices.Add(v);
            }

            foreach (var line in lines)
            {
                string[]        strings = line.Split("-");
                Vertex <string> vertex  = graph.Vertices.First(v => v.Value == strings[0]);

                foreach (string neighbour in strings[1].Split(","))
                {
                    if (neighbour != "")
                    {
                        var edge = new Edge <string>()
                        {
                            From = vertex, To = graph.Vertices.First(v => v.Value == neighbour)
                        };
                        graph.AddEdges(new [] { edge });
                    }
                }
            }

            return(graph);
        }
Пример #2
0
        private IGraph <MazeField> BuildGraphFromMaze(TwoDMaze maze)
        {
            GraphAdjList <MazeField> graph = new GraphAdjList <MazeField>();

            List <Vertex <MazeField> > vertices = new List <Vertex <MazeField> >();

            int W = maze.Fields.GetLength(0);
            int H = maze.Fields.GetLength(1);

            int[] ii = new[] { 0, 0, 1, -1 };
            int[] jj = new[] { 1, -1, 0, 0 };

            var verticeGrid = new Vertex <MazeField> [W, H];

            for (int i = 0; i < W; i++)
            {
                for (int j = 0; j < H; j++)
                {
                    if (maze.Fields[i, j].FieldType == FieldType.Obstacle)
                    {
                        continue;
                    }
                    verticeGrid[i, j] = new Vertex <MazeField>()
                    {
                        Value = maze.Fields[i, j]
                    };
                }
            }

            for (int i = 0; i < W; i++)
            {
                for (int j = 0; j < H; j++)
                {
                    if (maze.Fields[i, j].FieldType == FieldType.Obstacle)
                    {
                        continue;
                    }

                    for (int step = 0; step < 4; step++)
                    {
                        int nextX = i + ii[step];
                        int nextY = j + jj[step];

                        if (nextY >= H || nextY < 0)
                        {
                            continue;
                        }
                        if (nextX >= W || nextX < 0)
                        {
                            continue;
                        }

                        if (maze.Fields[nextX, nextY].FieldType == FieldType.Clear)
                        {
                            Edge <MazeField> edgeTo = new Edge <MazeField>()
                            {
                                From = verticeGrid[i, j],
                                To   = verticeGrid[nextX, nextY]
                            };

                            Edge <MazeField> edgeFrom = new Edge <MazeField>()
                            {
                                To   = verticeGrid[i, j],
                                From = verticeGrid[nextX, nextY]
                            };

                            graph.AddEdges(new [] { edgeFrom, edgeTo });
                        }
                    }

                    vertices.Add(verticeGrid[i, j]);
                }
            }

            graph.AddVertices(vertices);
            return(graph);
        }