static char *increasing_solution(char **tetris, char *sol, int width)
{
free(sol);
if ((sol = ft_strnew((width + 2) * (width + 1))) == NULL)
return (NULL);
init_solution(sol, width + 1);
reset_all_tetris(tetris);
return (sol);
}
void CVRP::constructGreedyRandomizedSolution(){
int n = 0;
double waitTime = 0.0;
int nVehi = deduce_nVehicles(0);
vector<Route*> solution(nVehi, new Route);
vector<int> route_capacity(nVehi, 0);
vector<double> routes_times(nVehi, 0.0);
vector<vector<Costumer*> > sol_candidates(solution.size(), vector<Costumer*> ());
dep.nVehicles = nVehi;
for(int i = 0; i < solution.size(); i++){
solution[i] = new Route;
}
//Initialize the solution with nearby close clients
init_solution(solution, routes_times, route_capacity, n);
while(n != clients.size()){
//Update the list of candidates
sol_candidates = update_list(solution, routes_times, n);
for(int c = 0; c < sol_candidates.size(); c++){
sort(sol_candidates[c].begin(), sol_candidates[c].end(), saving_heuristic);
}
//shrink_routes(solution);
select_candidate(solution, sol_candidates, routes_times, route_capacity, n);
}
double sum = 0.0;
cout << "Solution size: " << solution.size() << endl;
for(Route *r : solution){
for(Costumer *c : r->clients){
sum += c->cost;
cout << c->id << " ";
}
cout << endl;
}
cout << sum << endl;
cout << endl;
/*for(int i = 0; i < solution.size(); i++){
solution[i]->clients.push_front(new Costumer(0, dep.coord,0,0,0,0));
solution[i]->clients.push_back(new Costumer(0, dep.coord,0,0,0,0));
}*/
sol = solution;
for(Route *r : solution){
for(int i = 0; i < r->clients.size()-1; i++){
cout << r->clients[i]->id << ":" << r->clients[i]->arrTime + r->clients[i]->servTime << " " << r->clients[i+1]->id << ":" << r->clients[i+1]->dTime << endl;
}
cout << endl;
}
save();
}
Solution *new_solution(Puzzle *puz)
{
Solution *sol= (Solution *)malloc(sizeof(Solution));
dir_t i;
/* Copy size from puzzle */
for (i= 0; i < puz->nset; i++)
sol->n[i]= puz->n[i];
init_solution(puz, sol, 1);
return sol;
}
char *solver(char **tetris)
{
int i;
int j;
char *solution;
i = 0;
j = 0;
while (tetris[i])
++i;
i *= 4;
while (j * j < i)
++j;
if ((solution = ft_strnew((j + 1) * j)) == NULL)
return (NULL);
init_solution(solution, j);
while (!fill_solution(tetris, &solution, 0))
{
if ((solution = increasing_solution(tetris, solution, j)) == NULL)
return (NULL);
++j;
}
return (solution);
}
int main(int argc, char *argv[])
{
int i, j, p_id, p_total;
best_solution best;
matrix distances;
matrix * dist = NULL;
if (argc != 2){
fprintf(stderr, "Wrong arguments!\n");
return 1;
}
MPI_Init (&argc, &argv);
MPI_Comm_rank (MPI_COMM_WORLD, &p_id);
MPI_Comm_size(MPI_COMM_WORLD, &p_total);
if(p_total > 1)
{
//Root process has to read the input data...
if(p_id == 0)
{
read_distances(&distances, argv);
for(i=1; i<p_total; i++)
{
MPI_Send(&(distances.number_of_cities), 1, MPI_INT, i, TAG_SIZE, MPI_COMM_WORLD);
for(j=0; j<distances.number_of_cities; j++)
{
MPI_Send(distances.data[j], distances.number_of_cities, MPI_INT, i, TAG_DATA, MPI_COMM_WORLD);
}
MPI_Send(&distances.smallest_distance, 1, MPI_INT, i, TAG_SMALLEST, MPI_COMM_WORLD);
MPI_Send(distances.min_door, distances.number_of_cities, MPI_INT, i, TAG_MIN_DOOR, MPI_COMM_WORLD);
MPI_Send(&(distances.current_min_door), 1, MPI_INT, i, TAG_CURRENT_MIN_DOOR, MPI_COMM_WORLD);
}
} else
{
MPI_Recv(&number_of_cities, 1, MPI_INT, 0, TAG_SIZE, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
dist = (matrix*) malloc (sizeof(matrix));
dist->data = (int **)malloc(number_of_cities*sizeof(int*));
dist->min_door = (int*)malloc(number_of_cities*sizeof(int));
for(i=0; i<number_of_cities; i++){
dist->data[i] = (int *)malloc(number_of_cities*sizeof(int));
}
dist->number_of_cities =number_of_cities;
for(i=0; i<dist->number_of_cities; i++)
{
MPI_Recv(dist->data[i], number_of_cities, MPI_INT, 0, TAG_DATA, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
MPI_Recv(&smallest_distance, 1, MPI_INT, 0, TAG_SMALLEST, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(dist->min_door, number_of_cities, MPI_INT, 0, TAG_MIN_DOOR, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(¤t_min_door, 1, MPI_INT, 0, TAG_CURRENT_MIN_DOOR, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
dist->current_min_door=current_min_door;
dist->smallest_distance = smallest_distance;
distances.number_of_cities = dist->number_of_cities;
distances.data = dist->data;
distances.smallest_distance = dist->smallest_distance;
distances.min_door = dist->min_door;
distances.current_min_door = dist->current_min_door;
}
init_solution(&best, &distances, p_total-1, 1);
//Use the last process for heuristics
if(p_id != p_total-1)
{
perform_branch_and_bound(&distances, &best, p_id);
}else
{
perform_greedy(&distances, &best, p_id);
}
destroy_distance_matrice(dist, p_id);
} else
{
read_distances(&distances, argv);
init_solution(&best, &distances, p_total, 1);
perform_branch_and_bound(&distances, &best, p_id);
}
destroy_solution(&best, &distances);
destroy_matrix(&distances,p_id);
MPI_Finalize();
return (EXIT_SUCCESS);
}
