Ejemplo n.º 1
0
void GeneraAleatorio()
{
	srand(time(NULL));
	int max_nodos=10, min_nodos=6;
	int max_aristas=5,min_aristas=1;
	int min_peso=10,max_peso=50;
	
	int V=rand()%(max_nodos-min_nodos+1)+min_nodos;
	Grafo miGrafo;
	miGrafo.clear();
	miGrafo.resize(V);

	for(int i=0;i<miGrafo.size();i++){
		int num_aristas=rand()%(max_aristas-min_aristas+1)+min_aristas;
		for(int j=0;j<num_aristas;j++){
			bool nodo_ok=false;
			int nodoDestino=-1;
			while(!nodo_ok){
				int duplicado=0;
				nodoDestino=rand()%V;
				for(int k=0;k<miGrafo[i].size();k++){
					if(miGrafo[i][k].nodo==nodoDestino){
						duplicado=1;
						break;
					}
				}
				if(duplicado==0 && nodoDestino!=i)
					nodo_ok=true;
			}
			miGrafo[i].push_back(
				Edge(nodoDestino, rand()%(max_peso-min_peso)+min_peso+1)	);
		}
	}

	for(int i=0;i<miGrafo.size();i++){
		printf("%d: ",i);
		for(int j=0;j<miGrafo[i].size();j++){
			printf("(D: %d, P: %d)",miGrafo[i][j].nodo,miGrafo[i][j].peso);
		}
		printf("\n");
	}
	getchar();
}
Ejemplo n.º 2
0
void grasp_primer_criterio(Grafo& G, vector<int>& cidm, bool criterio_greedy, bool criterio_busqueda) {
    vector<int> mejor_solucion;
    construir_greedy_random(G, mejor_solucion, criterio_greedy);
    // Criterio de parada 1: hace tantas iteraciones como nodos en el grafo.
    for (int i = 0; i < G.size(); i++) {
        // Construir Solucion Greedy Random
        vector<int> nueva_solucion;
        construir_greedy_random(G, nueva_solucion, criterio_greedy);
        // Hacer busqueda local
        busqueda_local(G, nueva_solucion, criterio_busqueda);
        // Actualizar Mejor Solucion
        if (nueva_solucion.size() < mejor_solucion.size()) {
            mejor_solucion = nueva_solucion;
        }
    }
    cidm = mejor_solucion;
}
Ejemplo n.º 3
0
void construir_greedy_random_primer_criterio(Grafo& G, vector<int>& solucion) {
    // Criterio de Restricted Candidate List 1: los nodos que cumplan la condicion
    // de que su grado es por lo menos mejor_grado (de todos los nodos) * GREEDY_RANDOM_ALPHA.
    int n = G.size();
    Nodos nodos(n, Nodo());

    for(int u = 0; u < n; u++) {
        nodos[u].numero = u;
        nodos[u].grado = G[u].size();
    }

    sort(nodos.begin(), nodos.end(), orden());

    solucion = vector<int>(n, NO_INCLUIDO);

    int nodos_visitados = 0;
    while (nodos_visitados < n) {
        int mejor_grado = nodos[0].grado;
        int window_size = 0; // el maximo indice posible, la RCL va a ser nodos[0...window_size]
        for (int i = 0; i < nodos.size(); i++) {
            if (nodos[i].grado >= mejor_grado * GREEDY_RANDOM_ALPHA) {
                window_size = i;
            } else {
                break;
            }
        }

        int indice = random_in_range(0, min(window_size, (int)nodos.size()-1));

        int nodo = nodos[indice].numero;
        solucion[nodo] = INCLUIDO;
        nodos_visitados++;
        nodos.erase(nodos.begin()+indice);

        for (list<int>::iterator itAdyU=G[nodo].begin(); itAdyU != G[nodo].end(); itAdyU++) {
            int v = *itAdyU;
            int index = get_indice_nodo(nodos, v);
            if (index != -1) {
                // v no esta en el vector de nodos
                nodos.erase(nodos.begin()+index);
                nodos_visitados++;
            }
        }
    }
}
Ejemplo n.º 4
0
bool solucion_posible(Grafo& G, vector<int>& solucionCambiar, int cantCambios) {
  int n = G.size();
  bool esSolucion = true;
  bool finCiclo = false;
  list<int> verticesCambiados;

  for (int u = 0; u < n && !finCiclo; u++) {
    // Si esta INCLUIDO, sus adyacentes no pueden estar INCLUIDOS
    if (solucionCambiar[u] == INCLUIDO && G[u].size() > 0) {
      for (list<int>::iterator itAdyU=G[u].begin(); itAdyU != G[u].end() && !finCiclo; ++itAdyU) {
        int v = *itAdyU;
        if (solucionCambiar[v] == INCLUIDO) {
          esSolucion = false;
          finCiclo = true;
        }
      }
    } else if (G[u].size() > 0) {
      // Si esta NO INCLUIDO, al menos uno de sus adyacentes tiene que estar INCLUIDO
      bool adyINCLUIDO = false;
      for (list<int>::iterator itAdyU=G[u].begin(); itAdyU != G[u].end() && !finCiclo; ++itAdyU) {
        int v = *itAdyU;
        if (solucionCambiar[v] == INCLUIDO) {
          adyINCLUIDO = true;
        }
      }
      if (!adyINCLUIDO && cantCambios == 0) {
        esSolucion = false;
        finCiclo = true;
      } else if(!adyINCLUIDO) {
        // Salvo la solucion al marcar el vertice
        solucionCambiar[u] = INCLUIDO;
        cantCambios --;
      }
    } else {
      // Si es un K1, tiene que estar INCLUIDO
      esSolucion = solucionCambiar[u] == INCLUIDO;
      finCiclo = !(solucionCambiar[u] == INCLUIDO);
    }
  }

  return esSolucion;
}
Ejemplo n.º 5
0
void dijkstra(Grafo& grafo, unsigned inicio, vector<float>& pvecino, vector<unsigned>& vecino)
{
    unsigned dim = grafo.size();
    vecino = vector<unsigned>(dim, inicio);
    vector<bool> b = vector<bool>(dim, false);

    pvecino = vector<float>(dim);
    for (unsigned i = 0; i < dim; i++)
        pvecino[i] = grafo(inicio, i);

    b[inicio] = true;

    for (unsigned i = 1; i < dim; i++)
    {
        unsigned m = ~0;
        float min = INFINITY;

        for (unsigned j = 0; j < dim; j++)
        {
            if (!b[j] && 0 < pvecino[j] && pvecino[j] < min)
            {
                m = j;
                min = pvecino[j];
            }
        }

        b[m] = true;

        for (unsigned j = 0; j < dim; j++)
        {
            float pa;
            if (!b[j] && (pa = pvecino[m] + grafo(m, j)) < pvecino[j])
            {
                pvecino[j] = pa;
                vecino[j] = m;
            }
        }
    }
}
Ejemplo n.º 6
0
void construir_greedy_random_segundo_criterio(Grafo& G, vector<int>& solucion) {
    // Criterio de Restricted Candidate List 2: los nodos que cumplan la condicion
    // de estar entre los 'GREEDY_RANDOM_BETA' (definido antes) mejores nodos.
    int n = G.size();
    Nodos nodos(n, Nodo());

    for(int u = 0; u < n; u++) {
        nodos[u].numero = u;
        nodos[u].grado = G[u].size();
    }

    sort(nodos.begin(), nodos.end(), orden());

    solucion = vector<int>(n, NO_INCLUIDO);

    int nodos_visitados = 0;
    while (nodos_visitados < n) {
        int mejor_grado = nodos[0].grado;
        int window_size = GREEDY_RANDOM_BETA;  // el maximo indice posible, la RCL va a ser nodos[0...window_size]
        int indice = random_in_range(0, min(window_size, (int)nodos.size()-1));

        int nodo = nodos[indice].numero;
        solucion[nodo] = INCLUIDO;
        nodos_visitados++;
        nodos.erase(nodos.begin()+indice);

        for (list<int>::iterator itAdyU=G[nodo].begin(); itAdyU != G[nodo].end(); itAdyU++) {
            int v = *itAdyU;
            int index = get_indice_nodo(nodos, v);
            if (index != -1) {
                // v no esta en el vector de nodos
                nodos.erase(nodos.begin()+index);
                nodos_visitados++;
            }
        }
    }
}