elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Introducción a Git (Primera Parte)


  Mostrar Mensajes
Páginas: [1]
1  Programación / Programación C/C++ / pasar de c++ a c en: 13 Noviembre 2017, 22:32 pm
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:
// 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;
}
2  Programación / Programación C/C++ / ayuda urgente laberinto con grafos en: 20 Junio 2017, 02:33 am
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
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define TRUE 1
  5. #define FALSE 0
  6.  
  7. int filas, columnas;
  8. int num = 0;
  9. int V;
  10. int ** Grafo;
  11.  
  12. /****************************************************Firmas********************************************************************/
  13. void Imprimir();
  14. int Modificar();
  15. int **DaMemoriaGrafo();
  16. /*Fin firmas*/
  17.  
  18. void Lectura(){
  19. FILE *Archivo;
  20. int i,j; //Filas,Columnas
  21. int fil = -1;
  22. int col = -1;
  23. int salf = -1; // Coordenadas S
  24. int salc = -1;  // Coordenadas S
  25. char c;
  26. int **Laberinto;
  27. char **Aux;
  28.  
  29.  
  30. Archivo = fopen("datos.txt","r");
  31. fscanf(Archivo,"%d", &filas); //Se leen el numero de filas
  32. fscanf(Archivo,"%d\n", &columnas); //Se leen el numero de columnas
  33. //printf("%d %d",filas,columnas);
  34. V = filas + columnas;
  35.  
  36.  
  37. Laberinto = (int **)malloc(filas*sizeof(int*)); //Matriz que contendra el mapa de los nodos.
  38. for(i = 0; i<filas; i++){
  39. Laberinto[i] = (int*)malloc(columnas*sizeof(int));
  40. }
  41.  
  42. Aux = (char **)malloc(filas*sizeof(char*));   //Matriz que contiene el Laberinto original.
  43. for(i = 0; i<filas; i++){
  44. Aux[i] = (char*)malloc(columnas*sizeof(char));
  45. }
  46.  
  47. Grafo = DaMemoriaGrafo(V); // se
  48.  
  49. for(i = 0; i<filas; i++){
  50. for(j = 0; j<columnas; j++){
  51. fscanf(Archivo,"%c", &c);
  52. Aux[i][j] = c;
  53. if(c == '#'){ //Convertimos la matriz en 0 y 1.
  54. Laberinto[i][j] = -1; //1 si es una pared.
  55.  
  56. }else{
  57. Laberinto[i][j] = 0; //0  si es un espacio vacio.
  58. }
  59. if(c == 'E'){ //Recuperamos la posicion de la entrada.
  60. fil = i;
  61. col = j;
  62. }
  63. }
  64. fscanf(Archivo,"\n");
  65. }
  66. if((fil == -1)&&(col == -1)){
  67. printf("\nNo existe ninguna entrada para el laberinto\n");
  68. }
  69. Imprimir(Laberinto);
  70. printf("\n");
  71. Modificar(Laberinto);
  72. Crear_grafo(V,Laberinto,Grafo);
  73. printf("\n");
  74. Imprimir(Laberinto);
  75. fclose(Archivo);
  76. printf("%d", num); //Cantidad de nodos.
  77.  
  78. }
  79.  
  80. void Imprimir(int** Laberinto){
  81. int i,j;
  82. for(i = 0; i<filas;i++){
  83. for(j = 0; j<columnas;j++){
  84. printf("%d", Laberinto[i][j]);
  85. }
  86. printf("\n");
  87. }
  88.  
  89. }
  90.  
  91. int Modificar(int** Laberinto){
  92. int i,j;
  93. for(i = 0; i<filas;i++){
  94. for(j = 0; j<columnas;j++){
  95. if(Laberinto[i][j] == 0){
  96. Laberinto[i][j] = num;
  97. num++;
  98. }
  99.  
  100. }
  101. }
  102. }
  103.  
  104. int Crear_grafo(int V, int ** lab, int ** Grafo){
  105.  
  106. int i, j, id = 0;
  107. for(i = 1; i<V; i++){
  108. for(j = 1; j<V; j++){
  109. Grafo[i][j] = 0;
  110. /*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){
  111. Grafo[i][j] = 1;
  112. Grafo[j][i] = 1;
  113. id++;*/
  114. }
  115. printf("%d",Grafo[i][j]);
  116. }
  117. printf("\n");
  118. }
  119. }
  120.  
  121.  
  122.  
  123.  
  124. int **DaMemoriaGrafo(int n){
  125.    int **aux;
  126.    int i;
  127.  
  128.    aux = (int **)malloc(n*(sizeof(int *)));
  129.    if (!aux)
  130.    {
  131.        printf("\nNo hay memoria suficiente.");
  132.        exit(1);
  133.    }
  134.    for(i=0;i<n;i++)
  135.    {
  136.        aux[i] = (int *)malloc(n*(sizeof(int)));
  137.        if (!aux[i])
  138.        {
  139.            printf("\nNo hay memoria suficiente.");
  140.            exit(1);
  141.        }
  142.    }
  143.    return aux;
  144. }
  145.  
  146.  
  147.  
  148. int main(){
  149. Lectura();
  150. return 0;
  151. }
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines