O que é uma Spanning Tree?

Dado um gráfico não direcionado e associado,G=( V,E) uma árvore transversal do diagrama é uma árvore G que varia G (ou seja, incorpora cada vértice de ) e é um subgráfico de (cada borda da árvore tem um lugar com )

O que é uma Árvore Espanhola Base?

A despesa da árvore que atravessa é o agregado de cargas do considerável número de arestas da árvore. Pode haver muitas espalhadas sobre as árvores. A menor árvore transversal é a árvore transversal, onde a despesa é menor entre todas as árvores que se espalham sobre elas. Também pode haver muitas bases espalhadas sobre as árvores.

A menor propagação sobre a árvore tem aplicação direta no plano dos sistemas. É utilizado em cálculos que se aproximam da emissão de relatórios de vendas em viagem, emissão multi-terminal de menor corte e coordenação impecável com menor ponderação de custos. Outras aplicações funcionais são:

Investigação de Grupo

Reconhecimento de caligrafia

Divisão de imagens

Cálculo do Kruskal

Kruskal’s Calculation fabrica a propagação sobre uma árvore, incluindo bordas individualmente em uma árvore de cruzamento em desenvolvimento. O cálculo de Kruskal segue uma metodologia ávida, pois em cada ciclo encontra uma aresta que tem o menor peso e adiciona-a ao desenvolvimento espalhando-se sobre a árvore.

Passos de CaAlgoritmo:

Ordene as bordas dos gráficos com respeito aos seus pesos.

Comece a adicionar bordas ao MST desde a borda com o menor peso até a borda com o maior peso.

Adicione apenas arestas que não formam um ciclo , arestas que ligam apenas componentes desconectados.

 Então agora a questão é como verificar se os vértices estão ligados ou não?

Isto deve ser possível utilizando o DFS que começa a partir do vértice principal, nesse momento verifique se o vértice subsequente é visitado ou não. No entanto, a DFS fará com que o tempo de intricácia seja enorme, pois tem um pedido para onde está a quantidade de vértices, é o número de arestas. Portanto, a melhor disposição é “Disjoint Sets”:

Os conjuntos conjuntos conjuntos conjuntos serão conjuntos cuja convergência é o conjunto não preenchido, o que implica que não partilham nenhum componente para todos os efeitos e objectivos.

No cálculo do Kruskal, em cada ciclo escolheremos a aresta com o peso mais reduzido. Nesta linha, começaremos com a aresta com o peso mais reduzido primeiro, ou seja, as arestas com peso 1. Em seguida, escolheremos a segunda aresta com peso mínimo, ou seja, a aresta com peso 2. Note que estas duas arestas estão absolutamente desajustadas. Atualmente, a aresta seguinte será a terceira aresta mais reduzida, ou seja, a aresta com peso 3, que associa as duas partes desuniformes do gráfico. Atualmente, não estamos autorizados a pegar a aresta com peso 4, que fará um ciclo e não podemos ter nenhum ciclo. Portanto, escolheremos a quinta aresta menos pesada, ou seja, aresta com peso 5. Atualmente, as outras duas arestas farão ciclos e nós os desconsideraremos. Finalmente, acabamos com uma árvore de base com custo completo 11 ( = 1 + 2 + 3 + 5).

#incluir <iostream>

#incluir <vector>

#incluir <utilidade>

#incluir <algoritmo>

usando o namespace std;

const int MAX = 1e4 + 5;

int id[MAX], nós, bordas;

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

anular inicializar()

{

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

        id[i] = i;

}

int raiz(int x)

{

    while(id[x] != x)

    {

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

        x = id[x];

    }

    devolver x;

}

união nula1(int x, int y)

{

    int p = raiz(x);

    int q = raiz(y);

    id[p] = id[q];

}

longo kruskal(par< longo, par< longo, int, int> > p[])

{

    int x, y;

    custo longo, mínimoCusto = 0;

    for(int i = 0;i < bordas;++i)

    {

        // Selecionando as bordas uma a uma em ordem crescente desde o início

        x = p[i]. segundo. primeiro;

        y = p[i]. segundo. segundo;

        custo = p[i]. primeiro;

        // Verificar se a aresta selecionada está criando um ciclo ou não

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

        {

            mínimoCusto += custo;

            union1(x, y);

        }    

    }

    devolver mínimoCusto;

}

int main()

{

    int x, y;

    peso longo, custo, mínimoCusto;

    inicializar();

    cin >> nós >> bordas;

    for(int i = 0;i < bordas;++i)

    {

        cin >> x >> y >> peso;

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

    }

    // Ordenar as bordas em ordem ascendente

    sort(p, p + bordas);

    minimumCost = kruskal(p);

    cout << minimumCost << endl;

    devolver 0;

}

Algoritmo da Prim

O cálculo da Prim também usa a forma cobiçosa de lidar com a localização da árvore que atravessa a base. Em Demure’s Calculation, nós nos tornamos a árvore que atravessa a base desde uma posição inicial. Em contraste com uma borda no Kruskal’s, nós adicionamos um vértice ao desenvolvimento que se espalha sobre uma árvore no Prim’s.

Passos de cálculo:

Manter dois arranjos desajustados de vértices. Um contendo vértices que estão no desenvolvimento espalhados sobre a árvore e outro que não estão na árvore de cruzamento em desenvolvimento.

Selecione o vértice menos caro que está associado com a árvore de cruzamento em desenvolvimento e não está na árvore de cruzamento em desenvolvimento e inclua-o no desenvolvimento espalhado sobre uma árvore. Isto deve ser possível utilizando Linhas de Necessidade. Suplemente os vértices, que estão associados ao desenvolvimento da árvore de atravessamento, para a Linha de Necessidades.

Verifique se há ciclos. Para fazer isso, marque os hubs que foram escolhidos até agora e complemente apenas os hubs da Linha de Necessidade que não foram verificados.

No Cálculo de Prim, vamos começar com um centro discricionário (não faz diferença qual) e imprimi-lo. Em cada ciclo, vamos verificar outro vértice que é vizinho daquele que acabamos de carimbar. Como um cálculo cobiçoso, o cálculo do Demure escolherá o vértice menos caro e imprimirá o vértice. Assim, vamos basicamente escolher a borda com peso 1. No ciclo seguinte, temos três escolhas, bordas com peso 2, 3 e 4. Desta forma, vamos escolher a borda com peso 2 e imprimir o vértice. Atualmente temos novamente três alternativas, bordas com peso 3, 4 e 5. No entanto, não podemos escolher a aresta com o peso 3, pois ela está fazendo um ciclo. Assim, vamos escolher a aresta com peso 4 e acabamos com a árvore de cruzamento de base de custo absoluto 7 ( = 1 + 2 + 4).

Implementação:

#incluir <iostream>

#incluir <vector>

#include <queue>

#incluir <funcional>

#incluir <utilidade>

usando o namespace std;

const int MAX = 1e4 + 5;

par typedef< comprido, int> PII;

bool marcado[MAX];

vector < PII> adj[MAX];

longo longo prim(int x)

{

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

    int y;

    custo mínimo longoCusto = 0;

    PII p;

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

    enquanto(! Q. vazio())

    {

        // Selecione a borda com peso mínimo

        p = Q. top();

        Q. pop();

        x = p. segundo;

        // Verificação do ciclo

        if(marcado[x] == verdadeiro)

            continuar;

        mínimoCusto += p. primeiro;

        marcado[x] = verdadeiro;

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

        {

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

            if(marked[y] == falso)

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

        }

    }

    devolver mínimoCusto;

}

int main()

{

    nós int, bordas, x, y;

    peso longo, mínimoCusto;

    cin >> nós >> bordas;

    for(int i = 0;i < bordas;++i)

    {

        cin >> x >> y >> peso;

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

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

    }

    // Selecionando 1 como o nó inicial

    mínimoCusto = prim(1);

    cout << minimumCost << endl;

    devolver 0;

}