Árbol de expansión mínimo (matriz de adyacencia o lista de adyacencia)

Tema Descripción

El problema del árbol de expansión mínima es una clase muy importante de problemas en la producción y la vida real. Suponiendo que se necesita establecer una red de comunicación entre n ciudades, solo se necesitan n-1 líneas para conectar n ciudades. En este momento, es natural considerar tal problema, es decir, cómo establecer esta red de comunicación bajo la premisa de ahorrar dinero al máximo.

Una red conectada se puede usar para representar n ciudades y las líneas de comunicación que se pueden establecer entre n ciudades, donde los vértices de la red representan las ciudades, los bordes representan las líneas entre dos ciudades y los pesos asignados a los bordes representan el costos correspondientes. Para una red conectada con n vértices, se pueden establecer muchos árboles de expansión diferentes, y cada árbol de expansión puede ser una red de comunicación. Ahora, es necesario elegir un árbol de expansión que minimice el costo total. Este problema consiste en construir el árbol de expansión de costo mínimo de la red conectada, denominado árbol de expansión mínimo. El costo de un árbol de expansión es la suma de los costos de los bordes del árbol.

Entre los algoritmos de construcción de árbol de expansión mínima comúnmente utilizados, el algoritmo de Prim es un algoritmo muy utilizado.
En esta pregunta, lea los datos de un gráfico no dirigido y guárdelos en la matriz de adyacencia, luego use el algoritmo Prim para construir el árbol de expansión mínimo y genere el costo del árbol de expansión mínimo.


Este tema proporciona algunos programas de referencia.

ingresar

Línea 1: Ingrese el número total de vértices n y el número total de aristas e, separados por espacios. Donde n no excede de 50 y e no excede de 1000.
Línea 2: Ingrese los nombres de n vértices (tipo char)
y luego ingrese la línea e: ingrese los vértices y los pesos adjuntos a un borde en cada línea, como ab 5 

producción

Primero genere n-1 líneas, correspondientes a n-1 bordes del árbol de expansión mínimo construido, el formato es "(punto final del borde, punto final del borde): peso del borde" y finalmente genere el valor del costo total del árbol de expansión mínimo
, el formato es "minCost= valor total". Tenga en cuenta la salida de nueva línea al final de la línea.

#include <iostream>
#include <iomanip>
using namespace std;

#define Max 1000
#define MVNum 100         //最大顶点数
#define OK 1

typedef char VerTexType; //顶点信息
typedef int OtherInfo;    //和边相关的信息
typedef int ArcType;

//- - - - -图的邻接表存储表示- - - - -
typedef struct {
   int info;
   VerTexType vexs[MVNum];            //顶点表
   ArcType arcs[MVNum][MVNum];      //邻接矩阵
   int vexnum, arcnum;                //图的当前点数和边数
} Graph;

int LocateVex(const Graph &g, VerTexType v)
{
   //确定点v在G中的位置
   for(int i = 0; i < g.vexnum; ++i)
      if(g.vexs[i] == v)
         return i;
   return -1;
}//LocateVex


void CreateUDG(Graph &g)
{
   //采用邻接矩阵表示法，创建无向图G
   /****在此下面完成代码***************/
    int i,j,k,w;
    char v1,v2;
    cin>>g.vexnum>>g.arcnum;
    for(i=0;i<g.vexnum;i++)
    {
        cin>>g.vexs[i];
    }
    for(i=0;i<g.vexnum;i++)
    for(j=0;j<g.vexnum;j++)
    {
        if(i==j)g.arcs[i][j]=0;
        else g.arcs[i][j]=Max;
    }
    for(k=0;k<g.arcnum;k++)
    {
        cin>>v1>>v2>>w;
        i=LocateVex(g, v1);
        j=LocateVex(g, v2);
        g.arcs[i][j]=g.arcs[j][i]=w;
    }
   /***********************************/
}//CreateUDN

void mintree(Graph g,int ad[][MVNum],int n)
{
    int i,j,k,p,q,sum=0,m;
    p=0;q=0;
    ad[p][q]=Max;
    for( k=1; k<n; k++ )
    {     m = Max;
           for( i=0; i<n; i++ )
           {
                if( ad[i][i]==Max)
                {
                    for( j=1; j<n; j++ )
                    {
                        if( (ad[j][j]==0) && (ad[i][j]<m))
                        {
                            m = ad[i][j];   p = i;    q = j;
                        }
                    }
                }
            }
            cout<<"("<<g.vexs[p]<<","<<g.vexs[q]<<")"<<":"<<ad[p][q]<<endl;
            ad[q][q] = Max;
            sum+=ad[p][q];
    }
    cout<<"minCost="<<sum<<endl;
}

int main()
{
   Graph g;
   CreateUDG(g);
   mintree(g,g.arcs,g.vexnum);
   return 0;
}//main

Copia de entrada de muestra

6 10 
abcdef 
ab 6 
ac 1 
ad 5 
bc 5 
be 3 
cd 5 
ce 6 
cf 4 
df 2 
ef 6

Copia de salida de muestra

(a,c):1 
(c,f):4 
(f,d):2 
(c,b):5 
(b,e):3 
minCoste=15