public static ListaGenerica<String> caminoMasCorto(Grafo<String> G , String islaO , String islaD)
    {
        ListaGenerica<String> listaResultado = new ListaEnlazadaGenerica<String>();
        ListaGenerica<Vertice<String>> vertices = G.listaDeVertices();
        ListaGenerica<Vertice<String>> Q = new ListaEnlazadaGenerica<Vertice<String>>();
        int posO=0,posD=0;
        for(vertices.comenzar();!vertices.fin();)
        {
            Vertice<String> v = vertices.proximo();
            Q.agregarFinal(v);
            if(v.dato().equals(islaO))
            {
                posO = v.posicion();
            }
            if(v.dato().equals(islaD))
            {
                posD = v.posicion();
            }
        }
        if(posO == 0 && posD == 0)
            return listaResultado;
        /************************************************/
        boolean[] known = new boolean[vertices.tamanio()+1];
        int[] dist = new int[vertices.tamanio()+1];
        @SuppressWarnings("unchecked")
        Vertice<String>[] s =  new VerticeImplListAdy[vertices.tamanio()+1];

        for(int i = 1; i<=vertices.tamanio();i++)
            dist[i] = Integer.MAX_VALUE;
        dist[posO] = 0;

        while(!Q.esVacia())
        {
            Vertice<String> v = eliminarMin(Q,dist);
            ListaGenerica<Arista<String>> ady = G.listaDeAdyacentes(v);
            known[v.posicion()] = true;
            for(ady.comenzar();!ady.fin();)
            {
                Arista<String> arista = ady.proximo();
                if(!known[arista.verticeDestino().posicion()])
                {
                    Vertice<String> w = arista.verticeDestino();
                    int alt = dist[v.posicion()] + arista.peso();
                    if(alt<dist[w.posicion()])
                    {
                        dist[w.posicion()] = alt;
                        s[w.posicion()] = v;
                    }
                }
            }
        }

        Vertice<String> v = vertices.elemento(posD);
        while(v != null)
        {
            listaResultado.agregarFinal(v.dato());
            System.out.println(v.dato());
            v=s[v.posicion()];
        }

        return listaResultado;
    }

    private static Vertice<String> eliminarMin(ListaGenerica<Vertice<String>> Q, int[] dist)
    {
        Vertice<String> res = null;
        int distMin=Integer.MAX_VALUE;
        for(Q.comenzar();!Q.fin();)
        {
            Vertice<String> v = Q.proximo();
            if(dist[v.posicion()] < distMin)
            {
                distMin=dist[v.posicion()];
                res=v;
            }

        }
        Q.eliminar(res);
        return res;
    }