Che cos’è un albero che si estende?

Dato un grafico non indirizzato e associato,G=( V,E) un albero di attraversamento del diagramma è un albero G che va da G (cioè incorpora ogni vertice di ) ed è un sottografo di (ogni bordo dell’albero ha un posto con )

Che cos’è un albero di base?

La spesa dell’albero che attraversa è l’aggregato dei carichi del considerevole numero di spigoli dell’albero. Ci possono essere molti che si diffondono sugli alberi. L’albero che attraversa meno è l’albero di attraversamento dove la spesa è minore tra tutti gli alberi che si sparpagliano. Ci possono essere anche numerose basi che si sparpagliano sugli alberi.

Almeno la diffusione su albero ha un’applicazione diretta nel piano dei sistemi. È utilizzato nei calcoli che approssimano l’emissione del rappresentante di vendita di viaggio, l’emissione multiterminale meno tagliata e il coordinamento impeccabile meno ponderato dei costi. Altre applicazioni funzionali sono:

Indagine di gruppo

Riconoscimento della calligrafia

Divisione immagini

Calcolo di Kruskal

Kruskal’s Calculation produce lo spargimento su un albero includendo i bordi singolarmente in un albero che si sta sviluppando. Il calcolo di Kruskal persegue una metodologia entusiasmante, poiché in ogni ciclo trova un bordo che ha il peso minore e lo aggiunge allo sviluppo che si sviluppa sull’albero.

CaAlgoritmo Passi:

Ordina i bordi del grafico in base al loro peso.

Iniziare ad aggiungere i bordi al MST dal bordo con il peso più piccolo fino al bordo del peso più grande.

Aggiungere solo i bordi che non formano un ciclo , bordi che collegano solo componenti scollegati.

 Quindi ora la domanda è come controllare se i vertici sono collegati o meno?

Questo dovrebbe essere possibile utilizzando DFS che parte dal vertice principale, a quel punto controllare se il vertice successivo viene visitato o meno. Tuttavia, DFS renderà enorme la complessità del tempo in quanto ha una richiesta di dove è la quantità di vertici, è il numero di bordi. Quindi la migliore disposizione è “Disjoint Sets”:

Gli insiemi di disgiunzione saranno insiemi la cui convergenza è l’insieme non riempito, quindi implica che non condividono alcun componente a tutti gli effetti.

Nel calcolo di Kruskal, ad ogni ciclo sceglieremo il bordo con il peso più ridotto. Seguendo queste linee, inizieremo con il bordo con il peso più ridotto, cioè i bordi con il peso 1. Dopo di che sceglieremo il secondo bordo con il peso minimo, cioè il bordo con il peso 2. Notate che questi due bordi sono assolutamente disgiunti. Attualmente, il bordo seguente sarà il terzo bordo ponderato più ridotto, cioè il bordo con peso 3, che associa i due bit di disgiunzione del grafico. Attualmente, non ci è permesso di scegliere il bordo con il peso 4, che farà un ciclo e non possiamo avere cicli. Quindi sceglieremo il quinto bordo meno ponderato, cioè il bordo con il peso 5. Attualmente gli altri due bordi faranno dei cicli, quindi li ignoreremo. Alla fine, ci ritroviamo con un albero di traversata di base con costo completo 11 ( = 1 + 2 + 3 + 5).

#include <iostream>

#include <vettore>

#include <utilità>

#include <algoritmo>

utilizzando namespace std;

const int MAX = 1e4 + 5;

int id[MAX], nodi, bordi;

coppia < lunga lunga, coppia< int, int> > p[MAX];

inizializzare il vuoto()

{

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

        id[i] = i;

}

int root(int x)

{

    mentre(id[x] != x)

    {

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

        x = id[x];

    }

    restituire x;

}

unione vuota1(int x, int y)

{

    int p = radice(x);

    int q = radice(y);

    id[p] = id[q];

}

kruskal lungo lungo(coppia< lungo lungo, coppia< int, int> > p[])

{

    int x, y;

    costo lungo lungo, costo minimoCost = 0;

    per(int i = 0;i < bordi;++i)

    {

        // Selezione dei bordi uno ad uno in ordine crescente dall’inizio

        x = p[i]. secondo. primo;

        y = p[i]. secondo. secondo;

        costo = p[i]. prima;

        // Controllare se il bordo selezionato sta creando o meno un ciclo

        if(root(x) != root(y))

        {

            minimoCosto += costo;

            unione1(x, y);

        }    

    }

    Costo minimo di ritorno;

}

int main()

{

    int x, y;

    peso lungo lungo, costo, minimoCosto;

    inizializzare();

    cin >> nodi >> bordi;

    per(int i = 0;i < bordi;++i)

    {

        cin >> x >> y >> peso;

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

    }

    // Ordinare i bordi in ordine crescente

    tipo(p, p + bordi);

    minimumCost = kruskal(p);

    cout << minimoCosto << endl;

    restituire 0;

}

Algoritmo di Prim

Anche il Calcolo di Prim utilizza il metodo Covetous per localizzare l’albero di attraversamento di base. Nel Calcolo di Demure, diventiamo l’albero di attraversamento da una posizione iniziale. In contrasto con un bordo in Kruskal’s, aggiungiamo un vertice allo sviluppo che si sviluppa su un albero in Prim’s.

Fasi di calcolo:

Mantenere due disarticolazioni dei vertici. Uno contenente i vertici che si trovano nello sviluppo che si distribuiscono sull’albero e l’altro che non si trovano nell’albero di attraversamento che si sviluppa.

Selezionare il vertice meno costoso che è associato all’albero di attraversamento in via di sviluppo e che non si trova nell’albero di attraversamento in via di sviluppo e lo include nello sviluppo che si estende su un albero. Questo dovrebbe essere possibile utilizzando Need Lines. Integrare i vertici, che sono associati all’albero di attraversamento in via di sviluppo, nella Need Line.

Verificare la presenza di cicli. Per fare ciò, contrassegnare i mozzi che sono stati scelti e integrare solo i mozzi nella Need Line che non sono stati controllati.

Nel Calcolo di Prim, inizieremo con un hub discrezionale (non fa differenza quale) e lo imprimeremo. In ogni ciclo, controlleremo un altro vertice che è vicino a quello che abbiamo appena impresso. Come calcolo bramoso, il calcolo di Demure sceglierà il bordo meno costoso e imprimerà il vertice. Quindi, in pratica, sceglieremo il bordo con il peso 1. Nel ciclo successivo, abbiamo tre scelte, bordi con il peso 2, 3 e 4. In questo modo, sceglieremo il bordo con il peso 2 e imprimeremo il vertice. Anche in questo caso abbiamo tre alternative, bordi con peso 3, 4 e 5. Tuttavia, non possiamo scegliere il bordo con il peso 3 perché sta facendo un ciclo. Quindi sceglieremo il bordo con il peso 4 e finiremo con l’albero di attraversamento di base di costo assoluto 7 ( = 1 + 2 +4).

Attuazione:

#include <iostream>

#include <vettore>

#include <queue>

#include <funzionale>

#include <utilità>

utilizzando namespace std;

const int MAX = 1e4 + 5;

coppia tipedef< long long, int> PII;

contrassegnati con [MAX];

vettore < PII> adj[MAX];

lungo lungo prim(int x)

{

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

    int y;

    lungo lungo lungo minimoCosto = 0;

    PII p;

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

    mentre(! D. vuoto())

    {

        // Selezionare il bordo con peso minimo

        p = Q. top();

        D. pop();

        x = p. secondo;

        // Controllo del ciclo

        if(marcato[x] == vero)

            Continua;

        minimoCosto += p. prima;

        contrassegnato[x] = vero;

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

        {

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

            if(marcato[y] == falso)

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

        }

    }

    Costo minimo di ritorno;

}

int main()

{

    nodi int, bordi, x, y;

    peso lungo lungo, costo minimo;

    cin >> nodi >> bordi;

    per(int i = 0;i < bordi;++i)

    {

        cin >> x >> y >> peso;

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

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

    }

    // Selezione di 1 come nodo di partenza

    minimumCost = prim(1);

    cout << minimoCosto << endl;

    restituire 0;

}