int main() { // Estrutura List Route route; // Ler ponto de um arquivo std::ifstream ifs ("points.dat", std::ifstream::in); point aux(0,0); while (ifs >> aux.real() >> aux.imag()) { route.push_back(aux); } ifs.close(); // List teste // Algoritmo // Step 1: Calcular as poupanças sij=ci0+c0j-cij para i,j=1,...mn i!=j. Criar n rotas de veículos // (0,i,0) para i=1,...,n. Ordenar as economias num modo não crescente. int n=route.size(); double s[n][n-1]; point origin=*route.begin(); Route Aux; Subroute Sb; for (Route::iterator i=++route.begin(); i!=route.end(); ++i) { Aux.push_back(*i); Sb.push_back(Aux); for ( Route::iterator j=i; j!=route.end(); ++j) { if( i!=j) { s[i][j]( std::abs(*i-origin)+std::abs(origin-*j)-std::abs(*i-*j) ); } } Aux.clear(); } std::cout << Sb.size() << std::endl; s.sort(); for (std::list<double>::iterator i=s.begin(); i!=s.end(); ++i) std::cout << *i << std::endl; // Step 2: Iniciar do topo da lista de economias, executando o seguinte. Dada a economia sij, // determine se há duas rotas, uma contendo arco ou aresta (0,j) e a outra contendo o arco ou aresta // (i,0), que pode ser mescladas. Se então, combine essas duas rotas deletando (0,j) e (i,0) e // introduzindo (i,j). // Mesclar rotas for(Subroute::iterator I=Sb.end(); I!=Sb.begin(); --I) { } return 0; }
void simplifyRouteTest() { int row, column; cin >> row >> column; vector<vector<int> > board(HEIGHT, vector<int>(WIDTH, 0)); inputBoard(board); const int up = 0; const int right = 1; const int down = 2; const int left = 3; Route route; //vector<int> routes = { up, up, up, up, up, down, up, up, up, up, up, up, up // , up, up, up, up, up, up, up, up, right }; vector<int> routes = { down, down, down, down, down, up, left, down, right, down, down, up, up, up, up, up, up, up, up, up, up, up }; route.push_back(routes); debug(route); vector<vector<int>> board2 = board; moveByRoute(board, route, row, column); debug(board); cout << endl; Route simplifid; simplifyRoutePerfectly(route, row, column, simplifid); //_simplifyRouteNonMoving(board, route, row, column, simplifid); cout << endl; debug(simplifid); moveByRoute(board2, simplifid, row, column); debug(board2); }
Data GarbageCentral::getRoute(vector<GarbageDeposit*> to_pick) { if (to_pick.size() <= 1) throw RouteMissingData(); auto map = graph.dfs(); auto map_it = begin(map); Route route; vector<GarbageDeposit*> missing_deposits; GarbageDeposit* gd = new GarbageDeposit(); vector<GarbageDeposit*>::iterator gd1_it; while ( (gd1_it = find(begin(to_pick), end(to_pick), map_it->getPointer())) == end(to_pick) ) { map_it++; } *gd = **gd1_it; map_it++; while (to_pick.size() > 1) { if ( find(to_pick.begin(), to_pick.end(), map_it->getPointer()) != to_pick.end() ) { try { Section section = getShortestPath(gd, map_it->getPointer()); updatePicks(to_pick, section); route.push_back(section); *gd = *section.first[section.first.size() - 1]; } catch (NoOptimalPath &e) { missing_deposits.push_back(map_it->getPointer()); for (unsigned i = 0; i < to_pick.size(); i++) { if ( *to_pick[i] == *(map_it->getPointer()) ) { to_pick.erase(begin(to_pick) + i); break; } } } } map_it++; } delete gd; return make_pair(route, missing_deposits); }
void calcRoutes_4(int lookAheadCount) { //route, length std::queue<std::tuple<Route, int>> que; que.emplace(Route(), 0); for (int i = 0; i < LookAheadMax; i++) { _routes[i].clear(); } //bfsでルートを全列挙 while (!que.empty()) { auto tup = que.front(); que.pop(); int length = std::get<1>(tup); Route route = std::get<0>(tup); _routes[length].push_back(route); //debug(route); if (length == lookAheadCount) { continue; } int pre = route.top(); for (int i = 0; i < 4; i++) { if ((i + 2) % 4 == pre) continue;//行って戻るのは禁止 Route nextRoute = route; nextRoute.push_back(i); que.emplace(nextRoute, length + 1); } } }
inline void prepend(Route& route, const TpointRange& pointRange) { Path path; append(path, pointRange); route.push_back(path); }
inline void prepend(Route& route, const Segment& seg) { Path path; append(path, seg); route.push_back(path); }
inline void prepend(Route& route, const Point& p) { Path path; append(path, p); route.push_back(path); }
Pathfinding::Route Pathfinding::getPath(Entity* entity, const Vector3& goal) { stringstream prettyInfo; Vector3 start = entity->getPosition(); double a = phantom::Util::getTime(); _layer.cleanPathfinding(); Route route; if(_showDebug) { cout << endl<< endl<< endl<< endl; } if(_visualize) { getGraphics().clear(); } // Goal space uses a "strict" heuristic. EG: we don't want to walk into a tree. Space* goalSpace = _layer.getSpaceAtUsingHeuristic(goal, entity); // There is no "space" available at the destination. The entity probably wants // to walk into a tree. Returns an empty route. if(goalSpace == nullptr) { if(_showDebug) { cout << "Goal vector is not a space." << endl; } return route; } // Start space, first try using a strict heuristic. EG: If we start near a tree // we don't want to walk into that tree. Space* startSpace = _layer.getSpaceAtUsingHeuristic(start, entity); // Ok, did we find a start space with the strict heuristic? If not, it probably // means that our entity is stuck in a tree. Proceed with a less strict // heuristic. In most cases this will let the entity "leave" the solid object // that it's currently stuck on. if(startSpace == nullptr) { startSpace = _layer.getSpaceAtUsingHeuristic(start); } // Ok, we really can't walk anywhere. This is a rather odd case. Most likely // the user tried to walk outside of the BSP tree, or you've just found a bug // in the BSP tree. if(startSpace == nullptr) { if(_showDebug) { cout << "Start vector is not a space." << endl; } route.push_back(Vector3(goal)); return route; } if(_showDebug) { cout << "Starting at: " << startSpace->getArea().toString(); cout << "Ending at : " << goalSpace->getArea().toString(); } if(_visualize) { Box3& m = startSpace->getArea(); getGraphics().beginPath().setFillStyle(Color(0, 0, 127, 20)) .rect(m.origin.x+4, m.origin.y+4, m.size.x-8, m.size.y-8) .fill(); Box3& n = goalSpace->getArea(); getGraphics().beginPath().setFillStyle(Color(0, 0, 127, 20)) .rect(n.origin.x+4, n.origin.y+4, n.size.x-8, n.size.y-8) .fill(); } priority_queue<Space*, vector<Space*>, CompareShapesAstar> open; startSpace->isInOpenList = true; open.push(startSpace); if(_showBasicDebug) { prettyInfo << "Pathfinding overhead: " << std::fixed << (phantom::Util::getTime() - a) << " seconds. "; } int spacesScanned = 0; const double startTime = phantom::Util::getTime(); int timeout = 0; while(true) { if(open.empty()) { if(_showBasicDebug || _showDebug) { cout << " Open list empty." << endl; double now = phantom::Util::getTime(); if(_showBasicDebug) { prettyInfo << "No route found, scanned "<< spacesScanned << " Tile(s) in " << std::fixed << (now - startTime) << " seconds."; } } break; } if(timeout++ > 10000) { cout << " I give up after " << timeout << " tries. " << endl; double now = phantom::Util::getTime(); cout << "A* scanned " << spacesScanned << " Tile(s) in " << std::fixed << (now - startTime) << " seconds. " << endl; break; } Space* current = open.top(); open.pop(); if(_visualize) { //cout << " - Testing: " << current->getArea().toString(); drawRect(current, Color(0, 127, 127, 10)); } if(current == goalSpace) { if(_showDebug) { cout << " **** found! This is a good sign. " << endl; } unfoldRoute(route, current, startSpace, entity); if(!route.empty()) { route.pop_front(); Vector3 lastpos = goal - entity->getBoundingBox().size * 0.5; // Replace the last way-point with our mouse click coordinates: if(route.empty()) { route.push_back(lastpos); } else { route.back() = lastpos; } } double now = phantom::Util::getTime(); if(_showBasicDebug) { prettyInfo << "Found route, A* scanned " << spacesScanned << " Tile(s) in " << std::fixed << (now - startTime) << " seconds. Waypoint(s): " << route.size() << "."; } break; } vector<Space*>& neighbours = _layer.getNeighbours(current, entity); if(_showDebug && neighbours.empty()) { cout << " No neighbours found." << endl; } for(size_t i = 0; i < neighbours.size(); ++i) { Space* testing = neighbours[i]; if(!testing->isInOpenList) { spacesScanned++; testing->astarParent = current; testing->isInOpenList = true; testing->g = current->g + Services::settings()->pathfinding_g_cost; testing->h = calculateHeuristic(goalSpace, testing); testing->h = testing->h * testing->h; open.push(testing); } } } if(_showBasicDebug) { //cout << prettyInfo.str() << endl; Console::log(prettyInfo.str()); } return route; }