public void CheckOutOfRangeVertices()
    {
        double[,] graph = { { 0.0, 1.0 },
                            { 1.0, 0.0 } };
        DijkstraAlgorithm.Dijkstra AlgorithmClass = new DijkstraAlgorithm.Dijkstra(graph);

        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.GetMinimumDistance(-1));
        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.GetMinimumDistance(2));

        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.CallDijkstraAlgorithm(-1, 0));
        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.CallDijkstraAlgorithm(2, 0));
        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.CallDijkstraAlgorithm(0, -1));
        Assert.Throws <System.ArgumentOutOfRangeException>(() => AlgorithmClass.CallDijkstraAlgorithm(0, 2));
    }
    public void CheckOneVertice()
    {
        double[,] graph = { { 0.0 } };
        DijkstraAlgorithm.Dijkstra AlgorithmClass = new DijkstraAlgorithm.Dijkstra(graph);
        AlgorithmClass.CallDijkstraAlgorithm(0, 0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(0), 0.0);

        List <int> VerticesPath = new List <int> {
            0
        };

        Assert.AreEqual(AlgorithmClass.GetVerticesPath(), VerticesPath);
    }
    public void TestWikipediaExample()
    {
        double[,] graph = { {  0.0,  7.0,  9.0,  0.0, 0.0, 14.0 },
                            {  7.0,  0.0, 10.0, 15.0, 0.0,  0.0 },
                            {  9.0, 10.0,  0.0, 11.0, 0.0,  2.0 },
                            {  0.0, 15.0, 11.0,  0.0, 6.0,  0.0 },
                            {  0.0,  0.0,  0.0,  6.0, 0.0,  9.0 },
                            { 14.0,  0.0,  2.0,  0.0, 9.0,  0.0 } };
        DijkstraAlgorithm.Dijkstra AlgorithmClass = new DijkstraAlgorithm.Dijkstra(graph);
        AlgorithmClass.CallDijkstraAlgorithm(0, 5);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(0), 0.0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(1), 7.0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(2), 9.0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(3), 20.0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(4), 20.0);
        Assert.AreEqual(AlgorithmClass.GetMinimumDistance(5), 11.0);

        List <int> VerticesPath = new List <int> {
            0, 2, 5
        };

        Assert.AreEqual(AlgorithmClass.GetVerticesPath(), VerticesPath);
    }
        // Use this for initialization
        void Start()
        {
            // Исходные данные по сетке
            tgs = TerrainGridSystem.instance;
            List <Cell> myCells = tgs.cells;
            int         Nx      = tgs.rowCount;
            int         Nz      = tgs.columnCount;

            // Задать исходную высоту
            Cell    zeroCell  = myCells[0];
            Vector3 zeroCoord = tgs.CellGetPosition(0);

            using (var file = new StreamWriter(@"D:\Vec_grid.txt", true))
            {
                for (int row = 0; row < Nx; row++)
                {
                    for (int column = 0; column < Nz; column++)
                    {
                        Vector3 centerCoord = tgs.CellGetPosition(myCells[column + Nz * row]);
                        String  str         = centerCoord.x.ToString() + "\t" + centerCoord.z.ToString() + "\t" + centerCoord.y.ToString();
                        file.WriteLine(str);
                    }
                    file.WriteLine("\n");
                }
            }

            // Заполнить весы графа
            double[,] dijk_grid = new double[Nx * Nz, Nx *Nz];
            for (int row = 0; row < Nx; row++)
            {
                for (int column = 0; column < Nz; column++)
                {
                    int     currentIndex = column + Nz * row;
                    Vector3 centerCoord  = tgs.CellGetPosition(myCells[currentIndex]);

                    if (row != 0)
                    {
                        int     leftIndex = column + Nz * (row - 1);
                        Vector3 leftCoord = tgs.CellGetPosition(myCells[leftIndex]);
                        dijk_grid[currentIndex, leftIndex] = Vector3.Distance(centerCoord, leftCoord);
                    }

                    if (row != (Nx - 1))
                    {
                        int     rightIndex = column + Nz * (row + 1);
                        Vector3 rightCoord = tgs.CellGetPosition(myCells[rightIndex]);
                        dijk_grid[currentIndex, rightIndex] = Vector3.Distance(centerCoord, rightCoord);
                    }

                    if (column != (Nz - 1))
                    {
                        int     upIndex = (column + 1) + Nz * row;
                        Vector3 upCoord = tgs.CellGetPosition(myCells[upIndex]);
                        dijk_grid[currentIndex, upIndex] = Vector3.Distance(centerCoord, upCoord);
                    }

                    if (column != 0)
                    {
                        int     downIndex = (column - 1) + Nz * row;
                        Vector3 downCoord = tgs.CellGetPosition(myCells[downIndex]);
                        dijk_grid[currentIndex, downIndex] = Vector3.Distance(centerCoord, downCoord);
                    }

                    // ----------------

                    if ((row != 0) && (column != 0))
                    {
                        int     leftDownIndex = (column - 1) + Nz * (row - 1);
                        Vector3 leftDownCoord = tgs.CellGetPosition(myCells[leftDownIndex]);
                        dijk_grid[currentIndex, leftDownIndex] = Vector3.Distance(centerCoord, leftDownCoord);
                    }

                    if ((row != (Nx - 1)) && (column != 0))
                    {
                        int     rightDownIndex = (column - 1) + Nz * (row + 1);
                        Vector3 rightDownCoord = tgs.CellGetPosition(myCells[rightDownIndex]);
                        dijk_grid[currentIndex, rightDownIndex] = Vector3.Distance(centerCoord, rightDownCoord);
                    }

                    if ((row != 0) && (column != (Nz - 1)))
                    {
                        int     leftUpIndex = (column + 1) + Nz * (row - 1);
                        Vector3 leftUpCoord = tgs.CellGetPosition(myCells[leftUpIndex]);
                        dijk_grid[currentIndex, leftUpIndex] = Vector3.Distance(centerCoord, leftUpCoord);
                    }

                    if ((row != (Nx - 1)) && (column != (Nz - 1)))
                    {
                        int     rightUpIndex = (column + 1) + Nz * (row + 1);
                        Vector3 rightUpCoord = tgs.CellGetPosition(myCells[rightUpIndex]);
                        dijk_grid[currentIndex, rightUpIndex] = Vector3.Distance(centerCoord, rightUpCoord);
                    }
                }
            }

            DijkstraAlgorithm.Dijkstra AlgorithmClass = new DijkstraAlgorithm.Dijkstra(dijk_grid);
            AlgorithmClass.CallDijkstraAlgorithm(0, Nx * Nz - 1);
            double     distance = AlgorithmClass.GetMinimumDistance(Nx * Nz - 1);
            List <int> a        = AlgorithmClass.GetVerticesPath();

            using (var file = new StreamWriter(@"D:\Dijk_grid.txt", true))
            {
                for (int row = 0; row < Nx * Nz; row++)
                {
                    for (int column = 0; column < Nx * Nz; column++)
                    {
                        String str = dijk_grid[row, column] + "\t";
                        file.Write(str);
                    }
                    file.WriteLine("\n");
                }
            }
        }