Temas

hola buenas alguien me podria ayudar a pasar este codigo de c++ a c no se anda sobre c++ y no entiendo como se ttrabajan los arrays ahi

Código [Seleccionar] Expandir

// Declaraciones en el archivo .h
int cn; //cantidad de nodos
vector< vector<int> > ady; //matriz de adyacencia

// Devuelve la matriz de adyacencia del árbol mínimo.
vector< vector<int> > Grafo :: kruskal(){
    vector< vector<int> > adyacencia = this->ady;
    vector< vector<int> > arbol(cn);
    vector<int> pertenece(cn); // indica a que árbol pertenece el nodo

    for(int i = 0; i < cn; i++){
        arbol[i] = vector<int> (cn, 0);
        pertenece[i] = i;
    }

    int nodoA;
    int nodoB;
    int arcos = 1;
    while(arcos < cn){
        // Encontrar  el arco mínimo que no forma ciclo y guardar los nodos y la distancia.
        int min = INF;
        for(int i = 0; i < cn; i++)
            for(int j = 0; j < cn; j++)
                if(min > adyacencia[i][j] && adyacencia[i][j]!=0 && pertenece[i] != pertenece[j]){
                    min = adyacencia[i][j];
                    nodoA = i;
                    nodoB = j;
                }

        // Si los nodos no pertenecen al mismo árbol agrego el arco al árbol mínimo.
        if(pertenece[nodoA] != pertenece[nodoB]){
            arbol[nodoA][nodoB] = min;
            arbol[nodoB][nodoA] = min;

            // Todos los nodos del árbol del nodoB ahora pertenecen al árbol del nodoA.
        int temp = pertenece[nodoB];
        pertenece[nodoB] = pertenece[nodoA];
        for(int k = 0; k < cn; k++)
        if(pertenece[k] == temp)
        pertenece[k] = pertenece[nodoA];

            arcos++;
        }
    }
    return arbol;
}

estoy haciendo un programa que busque cualquier camino para un laberinto y que imprima la solución por pantalla hasta ahí todo bien pero tengo que buscar la solución con grafos y ni idea como crear la matriz de adyacencia a partir de mi matriz enumerada para poder leer el grafo con el algoritmo de djisktra.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0

int filas, columnas;
int num = 0;
int V;
int ** Grafo;

/****************************************************Firmas********************************************************************/
void Imprimir();
int Modificar();
int **DaMemoriaGrafo();
/*Fin firmas*/

void Lectura(){
FILE *Archivo;
int i,j; //Filas,Columnas
int fil = -1;
int col = -1;
int salf = -1; // Coordenadas S
int salc = -1;  // Coordenadas S
char c;
int **Laberinto;
char **Aux;


Archivo = fopen("datos.txt","r");
fscanf(Archivo,"%d", &filas); //Se leen el numero de filas
fscanf(Archivo,"%d\n", &columnas); //Se leen el numero de columnas
//printf("%d %d",filas,columnas);
V = filas + columnas;


Laberinto = (int **)malloc(filas*sizeof(int*)); //Matriz que contendra el mapa de los nodos.
for(i = 0; i<filas; i++){
Laberinto[i] = (int*)malloc(columnas*sizeof(int));
}

Aux = (char **)malloc(filas*sizeof(char*));   //Matriz que contiene el Laberinto original.
for(i = 0; i<filas; i++){
Aux[i] = (char*)malloc(columnas*sizeof(char));
}

Grafo = DaMemoriaGrafo(V); // se

for(i = 0; i<filas; i++){
for(j = 0; j<columnas; j++){
fscanf(Archivo,"%c", &c);
Aux[i][j] = c;
if(c == '#'){ //Convertimos la matriz en 0 y 1.
Laberinto[i][j] = -1; //1 si es una pared.

}else{
Laberinto[i][j] = 0; //0  si es un espacio vacio.
}
if(c == 'E'){ //Recuperamos la posicion de la entrada.
fil = i;
col = j;
}
}
fscanf(Archivo,"\n");
}
if((fil == -1)&&(col == -1)){
printf("\nNo existe ninguna entrada para el laberinto\n");
}
Imprimir(Laberinto);
printf("\n");
Modificar(Laberinto);
Crear_grafo(V,Laberinto,Grafo);
printf("\n");
Imprimir(Laberinto);
fclose(Archivo);
printf("%d", num); //Cantidad de nodos.

}

void Imprimir(int** Laberinto){
int i,j;
for(i = 0; i<filas;i++){
for(j = 0; j<columnas;j++){
printf("%d", Laberinto[i][j]);
}
printf("\n");
}

}

int Modificar(int** Laberinto){
int i,j;
for(i = 0; i<filas;i++){
for(j = 0; j<columnas;j++){
if(Laberinto[i][j] == 0){
Laberinto[i][j] = num;
num++;
}

}
}
}

int Crear_grafo(int V, int ** lab, int ** Grafo){

int i, j, id = 0;
for(i = 1; i<V; i++){
for(j = 1; j<V; j++){
Grafo[i][j] = 0;
/*if(lab[i][j] > id || lab[i+1][j] > id || lab[i][j+1] > id || lab[i-1][j] > id || lab[i][j-1] > id){
Grafo[i][j] = 1;
Grafo[j][i] = 1;
id++;*/
}
printf("%d",Grafo[i][j]);
}
printf("\n");
}
}

   


int **DaMemoriaGrafo(int n){
    int **aux;
    int i;

    aux = (int **)malloc(n*(sizeof(int *)));
    if (!aux)
    {
        printf("\nNo hay memoria suficiente.");
        exit(1);
    }
    for(i=0;i<n;i++)
    {
        aux[i] = (int *)malloc(n*(sizeof(int)));
        if (!aux[i])
        {
            printf("\nNo hay memoria suficiente.");
            exit(1);
        }
    }
    return aux;
}



int main(){
Lectura();
return 0;
}