Пример #1
0
        /*
         * Arvore Geradora Minimal de Kruskal
         * Retorna um grafo que representa a arvore de menor
         * caminho entre todos os vertices
         */
        public static AdjacencyList <T> Kruskal(Graph <T> graph)
        {
            //Obtem a lista de chaves do dicionario
            //Referencia direta aos vertices do grafo
            List <Vertex <T> > keys = graph.Vertices();
            //Lista de aresta do grafo base
            List <Edge <T> > E = graph.Edges();
            //Grafo temporario para busca em profundidade
            AdjacencyList <T> temp;
            //Iniciamos a nova lista de aresta da arvore a ser gerada
            List <Edge <T> > A = new List <Edge <T> >();

            //Para cada aresta de E, ordenada crescentemente
            foreach (Edge <T> uv in E)
            {
                //Os vertices se encontram na mesma componenete?
                //E possivel apartir do vertice de origem chegar
                //no vertice de destino
                bool isSameComponent;

                //Geramos um grafo com as arestas seguras
                temp = new AdjacencyList <T>(keys, A, graph.CompareTo());
                //Partimos da origem a procura do vertice de chegada
                temp.BFS(uv.from.value);
                var tempV = temp.Vertices().Find(x => x.value.Equals(uv.to.value));
                //Caso não seja possivel alcancar o vertice
                //Dizemos que não estao no mesmo componente
                isSameComponent = !float.IsPositiveInfinity(tempV.distance);
                //Caso não estejam no mesmo componente
                if (!isSameComponent)
                {
                    //Esta aresta e segura
                    A.Add(uv);
                }
            }
            //Retornamos o grafo gerado apartir da lista de arestas seguras
            return(new AdjacencyList <T>(keys, A, graph.CompareTo(), graph.isDirected));
        }
Пример #2
0
        static void Main(string[] args)
        {
            AdjacencyList <char> l = new AdjacencyList <char>((x, y) => x.CompareTo(y), false);

            /*
             * l.AddVertex('a');
             * l.AddVertex('b');
             * l.AddVertex('c');
             * l.AddVertex('d');
             * l.AddVertex('e');
             * l.AddVertex('f');
             *
             * l.AddEdge('a', 'b', 10);
             * l.AddEdge('b', 'c', 1);
             * l.AddEdge('c', 'e', 3);
             * l.AddEdge('e', 'd', -10);
             * l.AddEdge('d', 'b', 4);
             * l.AddEdge('e', 'f', 22);
             *
             * l.RemoveEdge('e', 'd', -10);
             * l.AddEdge('e', 'd', 2);
             *
             * l.AddVertex('g');
             * l.AddEdge('d', 'g', 14);
             *
             * l.AddEdge('b', 'd', 10);
             *
             * l.Edges().ForEach(x => Console.WriteLine(x));
             *
             * Console.WriteLine(l);
             *
             * Console.WriteLine(TreeAlgorithms<char>.Kruskal(l));
             */

            l.AddVertex('a');
            l.AddVertex('b');
            l.AddVertex('c');
            l.AddVertex('d');
            l.AddVertex('e');
            l.AddVertex('f');
            l.AddVertex('g');
            l.AddVertex('h');
            l.AddVertex('i');

            l.AddEdge('a', 'b', 4);
            l.AddEdge('a', 'h', 8);

            l.AddEdge('b', 'c', 8);
            l.AddEdge('b', 'h', 11);

            l.AddEdge('c', 'd', 7);
            l.AddEdge('c', 'f', 4);
            l.AddEdge('c', 'i', 2);

            l.AddEdge('d', 'e', 9);
            l.AddEdge('d', 'f', 14);

            l.AddEdge('e', 'f', 10);

            l.AddEdge('f', 'g', 2);

            l.AddEdge('g', 'h', 1);

            l.Edges().ForEach(x => Console.WriteLine(x));

            Console.WriteLine(l);

            Console.WriteLine(TreeAlgorithms <char> .Kruskal(l));
        }