Red de conocimiento del abogados - Respuesta jurídica de la empresa - Árbol de expansión mínima Algoritmo de Prim y algoritmo de Kruskal

Árbol de expansión mínima Algoritmo de Prim y algoritmo de Kruskal

La complejidad temporal del algoritmo de Kruskal está determinada principalmente por el método de clasificación. Su algoritmo de clasificación solo está relacionado con el número de aristas ponderadas y no tiene nada que ver con el número de vértices en el gráfico. complejidad temporal de O (eloge), la complejidad temporal del algoritmo de Kruskal es O (eloge). Por lo tanto, cuando el número de vértices del gráfico ponderado es grande y el número de aristas es pequeño, se utiliza el algoritmo de Kruskal para construir la Spanning mínima. ¡El árbol funciona mejor!

Algoritmo de Kruskal

Supongamos que WN=(V,{E}) es una red conectada que contiene n vértices, luego construya el árbol de expansión mínimo de acuerdo con el algoritmo de Kruskal. El proceso de a bosque. Después de eso, seleccione un borde con el peso más pequeño del conjunto de bordes E de la red. Si los dos vértices de este borde pertenecen a árboles diferentes, agréguelos al subgrafo, es decir, agregue los dos vértices al subgrafo. fusionarse en un solo árbol; de lo contrario, si los dos vértices del borde ya caen en el mismo árbol, no es aconsejable, tomar el borde con el peso más pequeño e intentarlo nuevamente. Y así sucesivamente, hasta que solo haya un árbol en el bosque, es decir, el subgrafo contiene n-1 aristas.

Algoritmo de Prim

Supongamos que WN=(V,{E}) es una red conectada que contiene n vértices, TV es el conjunto de vértices en el árbol de expansión mínimo en WN, TE es el conjunto de aristas en un árbol de expansión mínima. Claramente, al final de la ejecución del algoritmo, TV=V y TE es un subconjunto de E. Cuando el algoritmo comienza a ejecutarse, TE es un conjunto vacío y solo hay un vértice en TV. Por lo tanto, el proceso de construcción de un árbol de expansión mínimo según el algoritmo de Prim es: en total "un vértice ha caído en el árbol de expansión, pero el otro vértice aún no lo ha hecho. Elija un borde con el peso más pequeño entre los bordes que caen en el árbol de expansión y agréguelos al árbol de expansión uno por uno hasta que el árbol de expansión contenga n-1 bordes.

--Lo anterior se cargó desde /JudgeOnline/problem?id=1258

#include

#include

#include

usando el espacio de nombres std;

struct node

{

int v1;

int v2;

int len;

}e[10000];//Definir conjunto de bordes

int cmp(const void *a,const void * b)//Función de comparación de clasificación rápida

{

return ((node*)a)->len-((node*)b)->len;

}

int v[100],a[100][100];//v es un conjunto de puntos

void makeset(int n)

{

for(int i=0;i

v[i]=i;

}

int buscar(int x)

{

int h=x;

mientras(h!=v[h])

h=v[h];

return h;

}

int main()

{

int n,i,j,r1,r2,p,total;

mientras(scanf("%d",&n)!=EOF)

{

p=0;

total=0;

makeset(n);

for(i=0;i

{

for(j=0;j

{

scanf("%d ",&a [i][j]);

e[p].v1=i;

e[p].v2=j;

e[p ].len=a[i][j];

p++;

}

}

qsort(e ,p, tamañode(e[0]),cmp);

for(i=0;i

{

r1= buscar(e[i].v1);

r2=buscar(e[i].v2);

if(r1!=r2)

{

p>

total+=e[i].len;

v[r1]=r2;

}

}

printf("%d\n",total);

}

sistema("pausa");

devuelve 0;

}

2.Prim

//La dirección del título es la misma que la anterior

#include

usando el espacio de nombres std;

p>

#define M 101

#define maxnum 100001

int dis[M][M];

int prim(int n)

{

bool usado[M]={};

int d[M],i,j,k;

for(i=1; i<=n; i++)

d[i] = dis[1][i];

usado[1] = verdadero;

int suma=0;

for(i=1; i

int temp=maxnum;

for( j=1; j<=n; j++){

si( !usado[j] && d[j]

temp = d[j];

k = j;

}

}

usado[k] = verdadero;

suma += d[k];

for(j=1; j<=n; j++){

if( !used[j] && dis[k][j]

d[j] = dis[k][j]; // Diferencias con el algoritmo de Dijksta

}

}

suma de retorno;

}

int main()

{

int n,i,j

mientras( cin>>n ){

for(i=1; i<=n; i++){

for(j=1; j <=n ; j++){

scanf("%d",&dis[i][j]);

if( !dis[i][j] )

dis[i][j] = maxnum;

}

}

cout<

}

devuelve 0;

}

El código proviene de Internet