/************************************************************

-> Questo programma c++ implementa l'algoritmo d Kruskal

-> Si implementa Il Minimun Spanning Tree attraverso Kruskal per cercare i pesi
di un grafo non orientato e connesso G=(V,E)
-> Questo algoritmo ha una complessit di tempo T(n)=O(E log V);
-> Strutture Dati utilizzate:
Grafo: Matrice di Adiacenza
**************************************************************/
//------------------------ INIZIO PROGRAMMA ------------------------------------
-------------------
#include "kruskal.h" //includo l'header file kruskal.h
using namespace std;
int Kruskal::leggi_Grafo()// metodo per inserire il numero di nodi e i pesi del
grafo
{
cout<<"\nAlgoritmo di Kruskal : Minimum Spanning Tree\n"<<endl;
cout<<"Inserisci il no. di NODI nel grafo non orientato e connesso: ";
cin>>n;
if(n<=1){
cout<<"\n\nERRORE.Il numero di nodi inserito basso!\n\n"<<endl;
throw("abort");
}
no_a=0;
cout<<"Inserisci i PESI per i seguenti archi: \n";
for(int i=1;i<=n;i++)
{
for(int j=i+1;j<=n;j++)
{
cout<<"<"<<i<<" , "<<j<<">";
int peso;//peso dell'arco
cin>>peso;

if(peso!=0)// se il peso diverso da 0 incremento il numero di archi
{
no_a++;
graph_edge[no_a][1]=i;
graph_edge[no_a][2]=j;
graph_edge[no_a][3]=peso;
}
}
}
//STAMPA GLI ARCHI DEL GRAFO
cout<<"\n\nGLi ARCHI del grafo risultano essere: \n\n";
for(int i=1;i<=no_a;i++)
{
cout<<" < "<<graph_edge[i][1]
<<" , "<<graph_edge[i][2]
<<" > "<<graph_edge[i][3]<<endl;
}
}
void Kruskal::ordina_Archi()
{
/**** Ordina gli archi per peso usando il BUBBLE-SORT in ordine Crescente ******
********/
for(int i=1;i<=no_a-1;i++)
{
for(int j=1;j<=no_a-i;j++)
{ //Bubble-Sort ----------------------------------------------------------
--------
if(graph_edge[j][3]>graph_edge[j+1][3])
{
int t=graph_edge[j][1];
graph_edge[j][1]=graph_edge[j+1][1];
graph_edge[j+1][1]=t;
t=graph_edge[j][2];
graph_edge[j][2]=graph_edge[j+1][2];
graph_edge[j+1][2]=t;
t=graph_edge[j][3];
graph_edge[j][3]=graph_edge[j+1][3];
graph_edge[j+1][3]=t;
//----------------------------------------------------------------------
----------
}
}
}
// STAMPA GLI ARCHI ORDINATI PER PESO COL BUBBLE-SORT

cout<<"\n\nDopo l'ordinamento,gli archi risultano essere: \n\n";
for(int i=1;i<=no_a;i++)//scorro il numero di archi
cout<<""<< graph_edge[i][1]
<<" , "<<graph_edge[i][2]
<<" > ::"<<graph_edge[i][3]<<endl;
}
void Kruskal::algoritmo()//metodo che applica l'algoritmo di Kruskal per l'MST
{
//crea un set per ogni nodo
for(int i=1;i<=n;i++)
{
sets[i][1]=i;
top[i]=1;
}
cout<<endl;
cout<<"\n---::INIZIA L'ALGORITMO::---\n";
cout<<endl;
for(int i=1;i<=no_a;i++)
{
int p1=cerca_Nodo(graph_edge[i][1]);
int p2=cerca_Nodo(graph_edge[i][2]);
if(p1!=p2) // scrivi qualcosa-...
{ cout<<endl;
cout<<"L'arco incluso nell'ALBERO e': \n"
<<" < "<<graph_edge[i][1]<<" , "
<<graph_edge[i][2]<<" > "<<endl<<endl;
tree[graph_edge[i][1]][graph_edge[i][2]]=graph_edge[i][3];
tree[graph_edge[i][2]][graph_edge[i][1]]=graph_edge[i][3];
// Fondiamo i due sets(operazione di solito fatta con UNION(U,V))
for(int j=1;j<=top[p2];j++)
{
top[p1]++;
sets[p1][top[p1]]=sets[p2][j];//UNION(U,V)
}
top[p2]=0;
}
else
{
cout<<"Includo nell'arco "
<<" < "<<graph_edge[i][1]<<" , "
<<graph_edge[i][2]<<" > "<<"Forma un CICLO,quindi viene rimosso\n\n"
;// se l'arco forma un ciclo col nodo esso viene rimosso
}
}
}
int Kruskal::cerca_Nodo(int n)// cerchiamo il nodo
{
for(int i=1;i<=no_a;i++)//per l'indice che va da 1 fino a quando non minore
o uguale al numero archi
{
for(int j=1;j<=top[i];j++)//per j che va da 1 fino a quando non minore o
uguale all indice di riga della matrice top
{
if(n==sets[i][j])//se il nodo uguale a set[i][j] restituisce l'indice de
l nodo
return i;
}
}
return -1;
}
void Kruskal::stampa_Min_Span_Tree() //STAMPIAMO IL MINIMUM SPANNING TREE
{
for(int i=1;i<=n;i++)//le righe rappresentano la lista dei vertici
{
for(int j=1;j<=n;j++)//le colonne rappresentano gli archi tra i vertici
cout<<tree[i][j]<<"\t";//restituisce l'albero / matrice delle adiacenze
cout<<endl;
}
}
//****************************** MAIN **************************************
int main()
//passiamo semplicemente le variabili da utilizzare e i metodi per eseguire corr
ettamente l'algoritmo
{
Kruskal obj;
obj.leggi_Grafo();//inserisce il numero di nodi e i relativi pesi
obj.ordina_Archi();//ordina gli archi
obj.algoritmo();//effettua l'algoritmo kruskal per il MST
cout<<"Matrice delle Adiacenze"<<endl;
cout<<endl;
obj.stampa_Min_Span_Tree();//stampa l'albero/matrice di adiacenza
cout<<endl;
cout<<endl;
return 0;
}
//------------------ FINE PROGRAMMA --------------------------------------------
-------