¿Qué es un árbol de expansión?

Dada una gráfica no dirigida y asociada,G=( V,E) un árbol transversal del diagrama es un árbol G que abarca G (es decir, incorpora cada vértice de ) y es un subgrafo de (cada borde del árbol tiene un lugar con )

¿Qué es un árbol de expansión de la base?

El gasto del árbol transversal es el agregado de cargas del considerable número de bordes del árbol. Puede haber muchas que se extienden sobre los árboles. El árbol que menos se cruza es el árbol transversal, donde el gasto es menor entre todos los que se extienden sobre los árboles. También puede haber muchas bases que se extienden sobre los árboles.

La menor dispersión sobre el árbol tiene aplicación directa en el plan de sistemas. Se utiliza en los cálculos que se aproximan a la cuestión del representante de ventas de viaje, la cuestión del corte mínimo multi-terminal y la coordinación impecable menos ponderada por el costo. Otras aplicaciones funcionales son:

Grupo de Investigación

Reconocimiento de la caligrafía

División de imágenes

El cálculo de Kruskal

El cálculo de Kruskal fabrica la extensión sobre un árbol incluyendo los bordes individualmente en un árbol de cruce en desarrollo. El cálculo de Kruskal sigue una metodología entusiasta ya que en cada ciclo encuentra un borde que tiene el menor peso y lo añade a la propagación en desarrollo sobre el árbol.

Pasos de CaAlgoritmo:

Ordena los bordes del gráfico con respecto a sus pesos.

Comienza a agregar bordes al MST desde el borde con el menor peso hasta el borde del mayor peso.

Sólo agregue bordes que no formen un ciclo, bordes que sólo conecten componentes desconectados.

 Así que ahora la pregunta es cómo comprobar si los vértices están conectados o no…

Esto debería ser posible utilizando el DFS que comienza desde el vértice principal, en ese punto se comprueba si el vértice subsiguiente es visitado o no. Sin embargo, el DFS hará que el tiempo sea muy complicado ya que tiene una petición de dónde está la cantidad de vértices, es decir, el número de aristas. Por lo tanto, la mejor disposición es “Conjuntos Desconectados”:

Los conjuntos desarticulados serán conjuntos cuya convergencia es el conjunto sin relleno, por lo que implica que no comparten ningún componente a todos los efectos.

En el cálculo de Kruskal, en cada ciclo elegiremos el borde con el peso más reducido. En esta línea, comenzaremos primero con el borde de peso más reducido, es decir, los bordes con peso 1. Después elegiremos el segundo borde con peso mínimo, es decir, el borde con peso 2. Noten que estos dos bordes están absolutamente desarticulados. Actualmente, el siguiente borde será el tercer borde de peso más reducido, es decir, el borde con peso 3, que asocia los dos bits desarticulados del gráfico. Actualmente, no se nos permite elegir el borde con peso 4, que hará un ciclo y no podemos tener ningún ciclo. Así que elegiremos el quinto borde de menor peso, es decir, el borde con peso 5. Actualmente los otros dos bordes harán ciclos, así que no los tendremos en cuenta. Al final, terminamos con una base que atraviesa el árbol con un costo completo de 11 ( = 1 + 2 + 3 + 5).

#incluir < iostream>

#incluir <vector>

#incluir <utilidad>

#incluir <algoritmo>

usando namespace std;

Const int MAX = 1e4 + 5;

int id[MAX], nodos, bordes;

par < largo largo, par< int, int> > p[MAX];

anular inicializar()

{

    para(int i = 0;i < MAX;++i)

        id[i] = i;

}

int raíz(int x)

{

    mientras que(id[x] != x)

    {

        id[x] = id[id[x]];

        x = id[x];

    }

    Devuelva la X;

}

unión nula1(int x, int y)

{

    int p = raíz(x);

    int q = raíz(y);

    id[p] = id[q];

}

long long kruskal(pair< long long, pair< int, int> > p[])

{

    int x, y;

    largo costo, mínimo Costo = 0;

    para(int i = 0;i < bordes;++i)

    {

        // Seleccionando los bordes uno por uno en orden creciente desde el principio

        x = p[i]. segundo. primero;

        y = p[i]. segundo. segundo;

        costo = p[i]. primero;

        // Comprueba si el borde seleccionado está creando un ciclo o no

        si(raiz(x) != raiz(y))

        {

            Costo mínimo += costo;

            unión1(x, y);

        }    

    }

    retorno mínimo de costo;

}

int main()

{

    int x, y;

    largo peso, costo, mínimo costo;

    inicializar();

    nodos >> bordes;

    para(int i = 0;i < bordes;++i)

    {

        cin >> x >> y >> peso;

        p[i] = make_pair(peso, make_pair(x, y));

    }

    // Ordena los bordes en orden ascendente

    sort(p, p + bordes);

    Costo mínimo = kruskal(p);

    cout << mínimoCosto <<< endl;

    …devuelve 0;

}

Algoritmo de Prim

El cálculo de Prim también utiliza la forma codiciosa de tratar de localizar la base que atraviesa el árbol. En el cálculo de Demure, nos convertimos en el árbol transversal desde una posición inicial. En contraste con un borde en Kruskal, añadimos un vértice a la expansión en desarrollo sobre un árbol en Prim.

Pasos de cálculo:

Mantén dos arreglos de vértices desarticulados. Uno contiene vértices que están en desarrollo extendiéndose sobre el árbol y otro que no está en desarrollo cruzando el árbol.

Selecciona el vértice menos costoso que está asociado con el árbol transversal en desarrollo y no está en el árbol transversal en desarrollo y lo incluye en la propagación en desarrollo sobre un árbol. Esto debería ser posible utilizando las líneas de necesidad. Suplemente los vértices, que están asociados con el desarrollo del árbol transversal, en la Línea de Necesidad.

Comprueba si hay ciclos. Para ello, marque los cubos que han sido elegidos hasta ahora y complemente sólo los cubos de la Línea de Necesidad que no están marcados.

En el cálculo de Prim, comenzaremos con un centro discrecional (no importa cuál) y lo imprimiremos. En cada ciclo, comprobaremos otro vértice que es vecino al que acabamos de estampar. Como un cálculo codicioso, el cálculo de Demure elegirá el borde menos costoso e imprimirá el vértice. Así que básicamente elegiremos el borde con el peso 1. En el siguiente ciclo, tenemos tres opciones, bordes con peso 2, 3 y 4. De esta manera, elegiremos el borde con peso 2 e imprimiremos el vértice. Actualmente tenemos tres alternativas, bordes con peso 3, 4 y 5. Sin embargo, no podemos elegir el borde con el peso 3 ya que está haciendo un ciclo. Así que elegiremos el borde con el peso 4 y terminaremos con el árbol de cruce de la base del coste absoluto 7 ( = 1 + 2 +4).

Implementación:

#incluir < iostream>

#incluir <vector>

#incluir <cola>

#incluye <funcional>

#incluir <utilidad>

usando namespace std;

Const int MAX = 1e4 + 5;

typedef pair< long long, int> PII;

marcado como [MAX];

vector < PII> adj[MAX];

long long prim(int x)

{

    priority_queue< PII, vector< PII>, greater< PII> > Q;

    int y;

    largo largo mínimoCosto = 0;

    PII p;

    Q. push(make_pair(0, x));

    mientras(! Q. empty())

    {

        // Selecciona el borde con el peso mínimo

        p = Q. top();

        Q. pop();

        x = p. segundo;

        // Comprobando el ciclo

        if(marked[x] == true)

            Continúa;

        Costo mínimo += p. primero;

        marcado[x] = verdadero;

        for(int i = 0;i < adj[x]. size();++i)

        {

            y = adj[x][i]. segundo;

            if(marked[y] == false)

                Q. empuja(adj[x][i]);

        }

    }

    retorno mínimo de costo;

}

int main()

{

    nodos int, bordes, x, y;

    largo peso largo, mínimo costo;

    nodos >> bordes;

    para(int i = 0;i < bordes;++i)

    {

        cin >> x >> y >> peso;

        adj[x]. push_back(make_pair(peso, y));

        adj[y]. push_back(make_pair(peso, x));

    }

    // Seleccionando 1 como nodo de inicio

    Costo mínimo = prim(1);

    cout << mínimoCosto <<< endl;

    …devuelve 0;

}