Ejercicio 12
------------

    archipielago.h

    #ifndef ARCHIPIELAGO_H_
    #define ARCHIPIELAGO_H_

        typedef struct {
            vertice vOrigen, vDestino;
        }tipoPuente;

        typedef struct {
            int numPuentes;
            tipoPuente *Puentes;
        }tipoPuentes;

        typedef tipoPuentes *Puentes;
        typedef vertice vTipoCiudad;

        typdef struct {
            int numCiudades;
            vTipoCiudad *vCiudades;
        }vTipoCiudades;

        typedef vTipoCiudades *vCiudades;

        vCiudades LeerCiudades(const char *ruta);
        tipoPuente Grecoland(Grafo gIsla1, Grafo gIsla2, vCiudades C1,
        vCiudades C2);
    #endif



    archipielago.c

    vCiudades LeerCiudades(const char *ruta) {

        FILE *fichero;
        vCiudades C;
        int i;

        // Abrimos el fichero
        if((fichero = fopen(ruta, "r"))==NULL)
            error("LeerCiudades(): No ha sido posible abrir el fichero");

        // Reservamos memoria para la variable vCiudades
        if((C = (vCiudades)malloc(sizeof(vTipoCuidades)))==NULL)
            error("LeerCiudades(): No ha sido posible reservar espacio");

        // Cogemos el número de ciudades
        fscanf(fichero, "%d", C->numCiudades);

        // Reservamos memoria para vTipoCiudad
        if((C->vTipoCiudad = (vTipoCiudad*)malloc
        (sizeof(vTipoCiudad)*C->numCiudades))==NULLL)
            error("LeerCiudades(): No hay memoria disponible.");

        // Recogemos las ciudades del sistema
        for(i=0; i<C->numCiudades; i++)
            fscanf(fichero, "%d", C->vCiudades[i]);

        // Cerramos el fichero
        fclose(fichero);

        return C;
    }

    tipoPuente Grecoland(Grafo gIsla1, Grafo gIsla2, vCiudades C1, vCiudades C2) {
    {
        tipoPuente puente;
        Grafo gGreco;
        int n = gIsla1->numVert + gIsla2->numVert, i, j, k, l;
        tCoste tCostesMinimos[N][N];
        vertice vCaminosMinimos[N][N];
        tCoste tCosteMin = INFINITO;
        tCoste tCoste;

        gGreco = CrearGrafo(n);
        puente.o = 0;
        puente.d = I1->numVert;

        // Para cada par de ciudades costeras de cada isla:
        for(i = 0; i < C1->numCiudades; i++){
            for(j = 0; j < C2->numCiudades; j++){

                // Crear el grafo
                for(k = 0; k < gGreco->numVert; k++){
                    for(l = 0; l < gGreco->numVert; l++){
                        if(k < gIsla1->numVert && l < gIsla1->numVert)
                            gGreco->Costes[k][l] = gIsla1->Costes[k][l];
                        else if(k >= gIsla1->numVert && l >= gIsla1->numVert)
                            gGreco->Costes[k][l] = gIsla2->Costes[k-gIsla1->numVert][l-gIsla1->numVert];
                        else
                            gGreco->Costes[k][l] = INFINITO;
                    }
                }

                gGreco->Costes[C1->ciudades[i]][C2->ciudades[j]+gIsla1->numVert] = 0;
                gGreco->Costes[C2->ciudades[j]+gIsla1->numVert][C1->ciudades[i]] = 0;

                // Hacerle Floyd
                Floyd(gGreco, tCostesMinimos, vCaminosMinimos);

                // Sumar su coste
                tCoste = 0;
                for(k = 0; k < gGreco->numVert; k++)
                    for(l = 0; l < gGreco->numVert; l++)
                        tCoste = Suma(tCoste, tCostesMinimos[k][l]);

                // Mirar si es menor que el minimo hasta el momento
                if(tCoste < tCosteMin){
                    tCosteMin = tCoste;
                    puente.o = C1->ciudades[i];
                    puente.d = C2->ciudades[j];
                }
            }
        }
    return puente;
    }