public int removeWay(Vertex v1, Vertex v2, AdjacencyMatrix m)
        {
            int fv1 = 0, tv2 = 0;

            for (int i = 0; i < m.to.Length; i++)
            {
                if (v1.ID == m.to[i].vertex.ID)
                {
                    fv1 = i;
                }
                if (v2.ID == m.to[i].vertex.ID)
                {
                    tv2 = i;
                }
            }
            m.from[fv1].state = true;
            m.to[tv2].state   = true;
            //Позначаємо шлях з v2 в v1 як неможливий
            m.m[tv2, fv1] = m.maxValue;
            return(m.m[fv1, tv2]);
        }
        /// <summary>
        /// Вираховує оцінку обраного шляху
        /// </summary>
        /// <param name="g"></param>
        /// <param name="way"></param>
        /// <returns></returns>
        public int getPerstective(Graph g, List <Vertex> way)
        {
            int             result = 0;
            AdjacencyMatrix m      = new AdjacencyMatrix(g);

            //Викреслюємо пройдений шлях з матриці суміжності
            for (int i = 0; i < way.Count - 1; i++)
            {
                result += removeWay(way[i], way[i + 1], m);
            }
            //Оцінюємо невизначений шлях (from)
            int[] fmark = new int[m.from.Length];
            int[] tmark = new int[m.to.Length];
            #region --Віднімаємо від матриці мінімальні значення по рядках --
            for (int f = 0; f < fmark.Length; f++)
            {
                //вершина вже є в дереві
                if (m.from[f].state)
                {
                    fmark[f] = 0;
                    continue;
                }
                else
                {
                    //шукаємо мін в рядку
                    int min = Int16.MaxValue;
                    for (int t = 0; t < tmark.Length; t++)
                    {
                        //якщо вершина to не належить дереву
                        if (!m.to[t].state)
                        {
                            if (min > m.m[f, t])
                            {
                                min = m.m[f, t];
                            }
                        }
                    }
                    fmark[f] = min;
                }
            }
            //віднімаємо мінімальні значення в стовпцах від всіх елем. матриці
            for (int f = 0; f < m.from.Length; f++)
            {
                for (int t = 0; t < m.to.Length; t++)
                {
                    m.m[f, t] -= fmark[f];
                }
            }
            #endregion
            #region --Шукаємо мінімальні значення по стовпцях--
            for (int t = 0; t < tmark.Length; t++)
            {
                //вершина вже є в дереві
                if (m.to[t].state)
                {
                    tmark[t] = 0;
                    continue;
                }
                else
                {
                    //шукаємо мін в стовбці
                    int min = Int16.MaxValue;
                    for (int f = 0; f < fmark.Length; f++)
                    {
                        //якщо вершина to не належить дереву
                        if (!m.from[f].state)
                        {
                            if (min > m.m[f, t])
                            {
                                min = m.m[f, t];
                            }
                        }
                    }
                    tmark[t] = min;
                }
            }
            #endregion
            for (int f = 0; f < fmark.Length; f++)
            {
                if (!m.from[f].state)
                {
                    result += fmark[f];
                }
            }
            for (int t = 0; t < tmark.Length; t++)
            {
                if (!m.to[t].state)
                {
                    result += tmark[t];
                }
            }
            return(result);
        }