Ten en cuenta que el código no he podido probarlo y que intenta ser una guía.

Así, por ejemplo, si analizas el código ves que la inicialización de rectangulo es un poco rara:

class DatoDistancias
  {
    public:
      double distancia;
      Punto punto;
 
      DatoDistancias( const Punto& pt )
        : distancia( 1e9 ), punto( pt )
      { }
  };
 
  // ... 
 
  std::vector< DatoDistancias > rectangulo;
 
  rectangulo.push_back( Punto( -6.7071067, 0.7071067 ) );

Básicamente es un vector de elementos de tipo DatoDistancias pero yo le paso un punto. Quizás sería más conveniente escribir

rectangulo.push_back( DatoDistancias( Punto( -6.7071067, 0.7071067 ) ) );

Pero debería funcionar porque el constructor de DatoDistancias no se ha definido como "explicit", aún así lo dicho, donde estoy ahora mismo no puedo probar códigos y lo he hecho de cabeza.

Primera optimización: Si estás manejando coordenadas, lo suyo sería tener una estructura para manejarlos como tal.

class Punto
{
  public:
    double x;
    double y;
 
    Punto( double px, double py )
    : x( px ), y( py )
    {  }
};
 
struct Vpeaton
{
    int ad_peaton;     //numero del punto
    Punto punto;       // punto  
};
typedef std::vector<Vpeaton> V_peaton;

Segunda optimización: Si quieres calcular distancias... saca una función que la calcule en vez de repetir 8 veces el mismo cálculo. Reduces puntos de fallo y mejoras el mantenimiento y la legibilidad del código.

  V_peaton Areas;
 
  //buscar peston cercano a cada esquina.
  distminXsYs = distancia( punto_ supizq, Areas[0] );
  distminXiYs = distancia( punto_infizq, Areas[0] );
  distminXsYi = distancia( punto_supder, Areas[0] );
  distminXiYi = distancia( punto_infder, Areas[0] );
 
  for(int i=1; i<Areas.size(); i++)  
  {                  
    dist1 = distancia( punto_supizq, Areas[i] );
    dist2 = distancia( punto_infizq, Areas[i] );
    dist3 = distancia( punto_supder, Areas[i] );
    dist4 = distancia( punto_infder, Areas[i] );
 
    if (dist1<distminXsYs)
    {
      distminXsYs=dist1;
      peaton_1=Areas[i].ad_peaton;
    }
 
    if (dist2<distminXiYs)
    {
      distminXiYs=dist2;
      peaton_2=Areas[i].ad_peaton;
    }                               
 
    if(dist3<distminXsYi);
    {
      distminXsYi=dist3;
      peaton_3=Areas[i].ad_peaton;
    }
 
    if(dist4<distminXiYi);
    {
      distminXiYi=dist4;
      peaton_4=Areas[i].ad_peaton;
    }
  }

Tercera optimización: si asignas un valor inicial a las distancias lo suficientemente alto como para que cualquier punto posea una distancia inferior te puedes ahorrar las 4 primeras distancias y aglutinar todo en el for.

  V_peaton Areas;
 
  double distminXsYs = 1e9; // por ejemplo
  double distminXiYs = 1e9;
  double distminXsYi = 1e9;
  double distminXiYi = 1e9;
 
  for(int i=0; i<Areas.size(); i++)  
  {                  
    dist1 = distancia( punto_supizq, Areas[i] );
    dist2 = distancia( punto_infizq, Areas[i] );
    dist3 = distancia( punto_supder, Areas[i] );
    dist4 = distancia( punto_infder, Areas[i] );
 
    if (dist1<distminXsYs)
    {
      distminXsYs=dist1;
      peaton_1=Areas[i].ad_peaton;
    }
 
    if (dist2<distminXiYs)
    {
      distminXiYs=dist2;
      peaton_2=Areas[i].ad_peaton;
    }                               
 
    if(dist3<distminXsYi);
    {
      distminXsYi=dist3;
      peaton_3=Areas[i].ad_peaton;
    }
 
    if(dist4<distminXiYi);
    {
      distminXiYi=dist4;
      peaton_4=Areas[i].ad_peaton;
    }
  }

Con esto además corriges uno de tus problemas, y era que no asociabas valores a los peatones si la distancia mínima se encuentra en el punto 0.

Cuarta optimización: Podrías usar un vector de puntos para definir el rectángulo, con eso podrías evitar tener que comprobar la distancia con cada esquina de forma explícita.

  class DatoDistancias
  {
    public:
      double distancia;
      Punto punto;
 
      DatoDistancias( const Punto& pt )
        : distancia( 1e9 ), punto( pt )
      { }
  };
 
  V_peaton Areas;
  V_peaton peatones; // En vez de peaton_1, peaton_2, peaton_3, peaton_4; Hay que inicializarlo
 
  std::vector< DatoDistancias > rectangulo;
 
  // presupongo que los límites del cuadrado son conocidos. Si no es así esto se sustituiría por la inicialización correspondiente.
  rectangulo.push_back( Punto( -6.7071067, 0.7071067 ) );
  rectangulo.push_back( Punto( -6.7071067, -0.7071067 ) );
  rectangulo.push_back( Punto( 6.7071067, 0.7071067 ) );
  rectangulo.push_back( Punto( 6.7071067, -0.7071067 ) );
 
  for( int i=0; i<Areas.size(); i++)  
  {
    for ( int j=0; j<rectangulo.size( ); ++j )
    {
      double dist = distancia( rectangulo[j].punto, Areas[i] );
      if ( dist < rectangulo[j].distancia )
      {
        peatones[j] = Areas[i].ad_peaton;
        rectangulo[j].distancia = dist;
      }
    }
  }

Creo que el código final tiene bastante mejor pinta, no crees?

Y ya te digo yo que es muuucho más fácil corregir errores de esta forma.

La implementación de la función distancia no es que se me haya olvidado ponerla, con lo que tienes no te debería costar mucho implementarla.

Es complicado que alguien pruebe tu código porque usas la clase ListaSE que es particular tuya...si fuese un contenedor de la stl la cosa cambiaría... pero el comportamiento de ListaSE no se puede predecir viendo tu código.

Cualquier detalle tontos puede hacer que la ejecución del programa sea radicalmente distinta.

Tu piensa siempre que hacer un programa es como montar un reloj... todos los engranajes tienen que funcionar en perfecta armonía porque en caso contrario el invento no funciona.

Y tocando ahora tu código... me he mirado un poco la especificación de lo que tiene que hacer tu algoritmo y... yo creo que vas mal encaminado.

Para empezar, se supone que tiene que haber una función CaminoMinimo(i,j,k) o, en su defecto, tres bucles para iterar sobre el grafo... y tu estás usando únicamente 2 variables... lo mismo se me pasa algo, ya te digo, no puedo probarlo, pero lo veo raro.

También te digo que el diseño del algoritmo se puede resumir en una decena de líneas ( al menos las implementaciones que he visto )

Cuando tu defines una matriz de la forma en la que tú lo has hecho el equipo reserva la memoria de la siguiente manera:

matriz [ 3 ][ 2 ] = [ 0,0 ] [ 0,1 ] [ 1,0 ] [ 1,1 ] [ 2,0 ] [ 2,1 ]

Es decir, la matriz realmente está serializada en memoria y está ordenada por filas.

Si tu defines un argumento en una función tal que char matriz[][], no estás indicando el número de filas ni el número de columnas, por lo que la definición de dicha matriz está, técnicamente, incompleta.

Si quieres que no te de problemas puedes aplicar la solución más fácil, esta es poner en el parámetro el número de filas y de columnas.

void burbuja_descendente(char matriz[MAX][MAX],int n,int m);

Hay otras posibilidades, pero tendrías que modificar más código.

Todo uso de memoria dinámica implica el uso del heap.

Aunque existen funciones para crear varios heap ( que creo recordar que no son ni tan siquiera parte del estándar ), lo normal es no preocuparse demasiado por ello.

como normal general, salvo que explícitamente requieras el uso de heap específicos, para reservar memoria dinámicamente en c tienes:

* malloc: simplemente te reserva la memoria, no hace ninguna inicialización.
* calloc: reserva la memoria y la inicializa escribiendo ceros en todos los bytes.
* realloc: para cambiar la cantidad de memoria reservada.

y para liberarla, simplemente tienes free.

Los heaps pueden dar problema por ejemplo al mezclar librerías en debug y release... por ejemplo Qt 4 tenía un problema de este tipo al liberar listas... pero es bastante raro encontrarse un problema de estos... de hecho en mi caso el de Qt ha sido el primero con el que me he topado.

Te lo digo sin maldad, son detalles a pulir.

Tu piensa que cuanto mejor sea tu presentación y más facilites la vida a los que te van a ayudar, más productivo será para todos, en especial para ti.

Para que el texto sea legible, edita tu mensaje, selecciona todo el código y en el combobox donde pone GeSHi selecciona c++.

Y tampoco estaría mal que indicases qué tipo de clase es ListaSE... es un alias de vector, de set o de list... es una clase tuya propia que te has currado de cero... no sabes que hace eso ahi ( XDDD ) ???

Luego, entiendo que la función esa es un template, no?? si es template, para evitar dudas estaría bien que pusieses la declaración del template... en caso contrario ( espero que no ) tienes una clase llamada T... cambia el nombre de esa clase porque es usada para templates y puede dar lugar a confusiones.

Más cositas... CaminoMinimoFloyd es una función, por lo que para llamarla hay que encerrar los parámetros entre paréntesis y tu estás usando corchetes... esto directamente no compila, deberías corregir esos errores antes de reportar código... queda feo.

Y bueno, corrige esas tonterías y luego seguimos.

Te has trabado... donde exactamente??

Si quieres ayuda es un buen paso poner el código que tienes, comentar qué problemas tienes, cosas así...

Hombre, generar ese rango lo puedes hacer con un for

unsigned long long numero;
for ( numero=1000000000; numero<=9999999999; ++numero )
{
...
}

Lo que no se yo es la viabilidad de probar por fuerza bruta ese rango de claves...

suponiendo que pudieses probar 1000 claves por segundo probar todo el rango te llevaría: 2450 horas... 104 días

Eres capaz, para tener al menos la seguridad de que sabes qué estás haciendo, de decirme que intenta hacer la instrucción que tienes que completar??