Beispiel #1
0
void evaluate_bfs()
{
    Maze maze(9, 9);
    maze.buildMaze();

    BFS     bfs;
    Plot    *begin(maze.getPlot(0, 0));
    Plot    *goal(maze.getPlot(8, 8));

    std::cout << "BFS" << std::endl << "begin: " << begin << std::endl;

    bool res = begin == goal;

    std::chrono::time_point<std::chrono::system_clock> start, end;
    start = std::chrono::system_clock::now();

    auto node = bfs.search(maze.maze, *begin, *goal, maze.getMaxPlots());

    end = std::chrono::system_clock::now();
    int elapsed_seconds = std::chrono::duration_cast<std::chrono::nanoseconds> (end-start).count();
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);

    std::cout << "path.length: " << node->x << "=> (" << node->node->x << ", " << node->node->y << ")" << std::endl;
    std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds << "s\n";
}
Beispiel #2
0
double Components::perform_connected_compontents(SearchInputType search_input_type_)
{
    cout << endl << "Count connected components of graph ";

    double components = 0.;

    DFS * dfs;
    BFS * bfs;

    switch(search_input_type_){
    case enum_DFS  :
        dfs = new DFS (_graph, _debug);
        cout << "with DFS." << endl;
        break;
    case enum_BFS  :
        bfs = new BFS (_graph, _debug);
        cout << "with BFS." << endl;
        break;
    }

    vector<Node *> nodes = _graph->get_nodes();
    vector<Node *> visited_nodes;
    vector<Node *> found_nodes;

    for (size_t i = 0; i < nodes.size(); i++) {
        vector<Node *>::iterator it;
        it = find (visited_nodes.begin(), visited_nodes.end(), nodes[i]);
        if(it == visited_nodes.end()){ //No node found => not visited yet
            components++;
            switch(search_input_type_){
            case enum_DFS  :
                dfs->perform_recursive_DFS(i);
                found_nodes = dfs->get_found_nodes();
                break;
            case enum_BFS  :
                bfs->perform_iterative_BFS(i);
                found_nodes = bfs->get_found_nodes();
                break;
            }
            visited_nodes.insert(visited_nodes.end(),found_nodes.begin(),found_nodes.end());

        }
    }

    cout << endl << "The graph has " << components << " connected components." << endl;
}
void main()
{
	std::cout << "==== ALGORITHM REVIEW ====" << std::endl;
	//create a small tree
	Node<int> Root;
	Root.Data = 1;
	Root.ID = "root node";
	Node<int> LeftRoot;
	LeftRoot.Data = 2;
	LeftRoot.Left = nullptr;
	LeftRoot.Right = nullptr;
	LeftRoot.ID = "roots left child";
	Node<int> RightRoot;
	RightRoot.Data = 3;
	RightRoot.ID = "roots right child";
	Root.Left = &LeftRoot;
	Root.Right = &RightRoot;

	Node<int> RightLeft;
	RightLeft.Data = 4;
	RightLeft.Left = nullptr;
	RightLeft.Right = nullptr;
	RightLeft.ID = "the left child of roots right child";
	Node<int> RightRight;
	RightRight.Data = 5;
	RightRight.Left = nullptr;
	RightRight.Right = nullptr;
	RightRight.ID = "the right child of roots right child";

	RightRoot.Left = &RightLeft;
	RightRoot.Right = &RightRight;

	BFS<int> bfs;

	std::vector<Node<int>> start;
	start.push_back(Root);

	std::cout << bfs.search(start, 2) << std::endl;

	std::getchar();
}
Beispiel #4
0
void EstimateDimension(Map *m)
{
//	Graph *g = GraphSearchConstants::GetGraph(m);
//	GraphEnvironment ge(g);
//	std::vector<graphState> endPath;
//	node *n = g->GetRandomNode();
	Graph *g = GraphSearchConstants::GetGraph(m);
	GraphEnvironment ge(g);
	std::vector<graphState> endPath;
	
	// 1. choose a random point
	node *n = g->GetRandomNode();
	
	// 2. search to depth d (all g-costs >= d)
	double limit = 0;
	TemplateAStar<graphState, graphMove, GraphEnvironment> theSearch;
	theSearch.SetStopAfterGoal(false);
	theSearch.InitializeSearch(&ge, n->GetNum(), n->GetNum(), endPath);
	while (1)
	{
		double gCost;
		graphState s = theSearch.CheckNextNode();
		theSearch.GetClosedListGCost(s, gCost);
		//printf("Expanding g-cost %f next\n", gCost);
		if (gCost >= limit)
		{
			printf("%d\t%d\n", (int)limit, theSearch.GetNodesExpanded());
			limit++;
		}

		if (theSearch.DoSingleSearchStep(endPath))
			break;
	}	
	graphState start = n->GetNum();
	BFS<graphState, graphMove> b;
	b.GetPath(&ge, start, start, endPath);
}
Beispiel #5
0
int main (int argc, char* argv[])
{
    /** We create a command line parser. */
    OptionsParser parser;
    parser.push_back (new OptionOneParam (STR_URI_INPUT,  "graph file", true));

    IProperties* params = 0;

    try  {
        /** We parse the user options. */
        params = parser.parse (argc, argv);
    }
    catch (OptionFailure& e)
    {
        e.getParser().displayErrors (stdout);
        e.getParser().displayHelp   (stdout);
        return EXIT_FAILURE;
    }

    // We create the graph with the bank and other options
    Graph graph = Graph::load (params->getStr(STR_URI_INPUT));

    // We create a graph marker.
    GraphMarker<BranchingNode> marker (graph);

    // We create an object for Breadth First Search for the de Bruijn graph.
    BFS<BranchingNode> bfs (graph);

    // We want to compute the distribution of connected components of the branching nodes.
    //    - key is a connected component class (for a given number of branching nodes for this component)
    //    - value is the number of times this component class occurs in the branching sub graph
    map<size_t,Entry> distrib;

    // We get an iterator for all nodes of the graph. We use a progress iterator to get some progress feedback
    ProgressGraphIterator<BranchingNode,ProgressTimer>  itBranching (graph.iterator<BranchingNode>(), "statistics");

    // We want to know the number of connected components
    size_t nbConnectedComponents = 0;

    // We define some kind of unique identifier for a couple (indegree,outdegree)
    map <InOut_t, size_t> topology;

    size_t simplePathSizeMin = ~0;
    size_t simplePathSizeMax =  0;


    // We want time duration of the iteration
    TimeInfo ti;
    ti.start ("compute");

    // We loop the branching nodes
    for (itBranching.first(); !itBranching.isDone(); itBranching.next())
    {
        // We get branching nodes neighbors for the current branching node.
        Graph::Vector<BranchingEdge> successors   = graph.successors  <BranchingEdge> (*itBranching);
        Graph::Vector<BranchingEdge> predecessors = graph.predecessors<BranchingEdge> (*itBranching);

        // We increase the occurrences number for the current couple (in/out) neighbors
        topology [make_pair(predecessors.size(), successors.size())] ++;

        // We loop the in/out neighbors and update min/max simple path size
        for (size_t i=0; i<successors.size(); i++)
        {
            simplePathSizeMax = std::max (simplePathSizeMax, successors[i].distance);
            simplePathSizeMin = std::min (simplePathSizeMin, successors[i].distance);
        }
        for (size_t i=0; i<predecessors.size(); i++)
        {
            simplePathSizeMax = std::max (simplePathSizeMax, predecessors[i].distance);
            simplePathSizeMin = std::min (simplePathSizeMin, predecessors[i].distance);
        }

        // We skip already visited nodes.
        if (marker.isMarked (*itBranching))  {
            continue;
        }

        // We launch the breadth first search; we get as a result the set of branching nodes in this component
        const set<BranchingNode>& component = bfs.run (*itBranching);

        // We mark the nodes for this connected component
        marker.mark (component);

        // We update our distribution
        distrib[component.size()].nbOccurs += 1;

        // We update the number of connected components.
        nbConnectedComponents++;
    }

    ti.stop ("compute");

    // We compute the total number of branching nodes in all connected components.
    size_t sumOccurs = 0;
    size_t sumKmers = 0;
    for (map<size_t,Entry>::iterator it = distrib.begin(); it != distrib.end(); it++)
    {
        sumOccurs += it->first*it->second.nbOccurs;
        sumKmers  += it->second.nbKmers;
    }

    // We sort the statistics by decreasing occurrence numbers. Since map have its own ordering, we need to put all
    // the data into a vector and sort it with our own sorting criteria.
    vector < pair<InOut_t,size_t> >  stats;
    for (map <InOut_t, size_t>::iterator it = topology.begin(); it != topology.end(); it++)  {
        stats.push_back (*it);
    }

    sort (stats.begin(), stats.end(), CompareFct);

    // Note: it must be equal to the number of branching nodes of the graph
    assert (sumOccurs == itBranching.size());

    // We aggregate the computed information
    Properties props ("topology");

    props.add (1, "graph");
    props.add (2, "name",                    "%s", graph.getName().c_str());
    props.add (2, "db_input",                "%s", graph.getInfo().getStr("input").c_str());
    props.add (2, "db_nb_seq",               "%d", graph.getInfo().getInt("sequences_number"));
    props.add (2, "db_size",                 "%d", graph.getInfo().getInt("sequences_size"));
    props.add (2, "kmer_size",               "%d", graph.getInfo().getInt("kmer_size"));
    props.add (2, "kmer_nks",                "%d", graph.getInfo().getInt("nks"));
    props.add (2, "nb_nodes",                "%d", graph.getInfo().getInt("kmers_nb_solid"));
    props.add (2, "nb_branching_nodes",      "%d", graph.getInfo().getInt("nb_branching"));
    props.add (2, "percent_branching_nodes", "%.1f",
               graph.getInfo().getInt("kmers_nb_solid") > 0 ?
               100.0 * (float)graph.getInfo().getInt("nb_branching") / (float) graph.getInfo().getInt("kmers_nb_solid") : 0
              );

    props.add (1, "branching_nodes");

    props.add (2, "simple_path");
    props.add (3, "size_min", "%d", simplePathSizeMin);
    props.add (3, "size_max", "%d", simplePathSizeMax);

    props.add (2, "neighborhoods");
    for (size_t i=0; i<stats.size(); i++)
    {
        props.add (3, "neighborhood", "in=%d out=%d", stats[i].first.first, stats[i].first.second);
        props.add (4, "nb_bnodes",     "%d",    stats[i].second);
        props.add (4, "percentage",   "%5.2f", itBranching.size() > 0 ?
                   100.0*(float)stats[i].second / (float)itBranching.size() : 0
                  );
    }

    props.add (2, "connected_components");
    props.add (3, "nb_classes",    "%d", distrib.size());
    props.add (3, "nb_components", "%d", nbConnectedComponents);
    for (map<size_t,Entry>::iterator it = distrib.begin(); it!=distrib.end(); it++)
    {
        props.add (3, "component_class");
        props.add (4, "nb_occurs",    "%d", it->second.nbOccurs);
        props.add (4, "nb_bnodes",    "%d", it->first);
        props.add (4, "freq_bnodes",  "%f", sumOccurs > 0 ?
                   100.0*(float)(it->first*it->second.nbOccurs) / (float)sumOccurs : 0
                  );
    }
    props.add (1, ti.getProperties("time"));

    // We dump the results in a XML file in the current directory
    XmlDumpPropertiesVisitor v (graph.getName() + ".xml", false);
    props.accept (&v);

    return EXIT_SUCCESS;
}
Beispiel #6
0
int main()
{
	Graph *graph = Graph::create(9);

	graph_info info;
    info.source = 0;
    info.destination = 0;

    graph->addEdge(0, 1, 4);
    graph->addEdge(0, 7, 8);
    graph->addEdge(1, 2, 8);
    graph->addEdge(1, 7, 11);
    graph->addEdge(2, 3, 7);
    graph->addEdge(2, 8, 2);
    graph->addEdge(2, 5, 4);
    graph->addEdge(3, 4, 9);
    graph->addEdge(3, 5, 14);
    graph->addEdge(4, 5, 10);
    graph->addEdge(5, 6, 2);
    graph->addEdge(6, 7, 1);
    graph->addEdge(6, 8, 6);
    graph->addEdge(7, 8, 7);

    // DFS
    LOG("======== DFS start========");
    DFS *dfs = DFS::create(graph, info);
    dfs->compute();
    delete(dfs);
    LOG("======== DFS end========");

    // BFS
    LOG("======== BFS start========");
    BFS *bfs = BFS::create(graph, info);
    bfs->compute();
    delete(bfs);
    LOG("======== BFS end========");

    // dijkstra
    LOG("======== dijkstra start========");
    dijkstra *dijkstra = dijkstra::create(graph, info);
    dijkstra->compute();
    delete(bfs);
    LOG("======== dijkstra end========");

    // PrimMST
    LOG("======== PrimMST start========");
    PrimMST *prim = PrimMST::create(graph, info);
    prim->compute();
    delete(prim);
    LOG("======== PrimMST end========");

    // BellmanFord
    LOG("======== BellmanFord start========");
    BellmanFord *bellman_ford = BellmanFord::create(graph, info);
    bellman_ford->compute();
    delete(bellman_ford);
    LOG("======== BellmanFord end========");

    // ShortestPath
    LOG("======== ShortestPath start========");
    ShortestPath *shortest_path = ShortestPath::create(graph, info);
    shortest_path->compute();
    delete(shortest_path);
    LOG("======== ShortestPath end========");

    // Detect Cycle
    LOG("======== Detect Cycle start========");
    isCyclic(graph, info);
    LOG("======== Detect Cycle end========");

    // Detect Cycle using Disjoint set
    LOG("======== Detect Cycle using Disjoint set start========");
    LOG(isCyclicUsingDisjointSet(graph, info));
    LOG("======== Detect Cycle using Disjoint set end========");

    // Graph Coloring
    LOG("======== Graph Coloring start========");
    GraphColoring *graph_color = GraphColoring::create(graph, info);
    graph_color->color();
    graph_color->print();
    LOG("======== Graph Coloring end========");

    // Hamilton Cycle
    LOG("======== Hamilton Cycle start========");
    HamiltonCycle *hamiton = HamiltonCycle::create(graph, info);
    hamiton->checkHamiltonCycle();
    LOG("======== Hamilton Cycle end========");

    delete graph;

    // Directed Graph
    graph = Graph::create(6);

    graph->addDirectedEdge(0, 1);
    graph->addDirectedEdge(0, 5);
    graph->addDirectedEdge(1, 2);
    graph->addDirectedEdge(1, 3);
    graph->addDirectedEdge(1, 4);
    graph->addDirectedEdge(2, 3);
    graph->addDirectedEdge(2, 4);
    graph->addDirectedEdge(3, 4);
    graph->addDirectedEdge(5, 2);

    LOG("======== Topological Sort start========");
    TopologicalSort *tsort = TopologicalSort::create(graph, info);
    tsort->sort();
    tsort->print();
    LOG("======== Topological Sort end========");

	return 0;
}
Beispiel #7
0
int main (int argc, char* argv[])
{
    /** We create a command line parser. */
    OptionsParser parser ("GraphStats");
    parser.push_back (new OptionOneParam (STR_URI_GRAPH, "graph input",  true));

    try
    {
        /** We parse the user options. */
        IProperties* options = parser.parse (argc, argv);

        // We load the graph
        Graph graph = Graph::load (options->getStr(STR_URI_GRAPH));

        // We create a graph marker.
        GraphMarker marker (graph);

        // We create an object for Breadth First Search for the de Bruijn graph.
        BFS bfs (graph);

        // We want to compute the distribution of connected components of the branching nodes.
        //    - key is a connected component class (for a given number of branching nodes for this component)
        //    - value is the number of times this component class occurs in the branching sub graph
        map<size_t,size_t> distrib;

        // We get an iterator for all nodes of the graph. We use a progress iterator to get some progress feedback
        ProgressGraphIterator<BranchingNode,ProgressTimer>  itBranching (graph.iteratorBranching(), "statistics");

        // We want time duration of the iteration
        TimeInfo ti;
        ti.start ("compute");

        // We need to keep each connected component.
        list<set<BranchingNode> > components;

        // We loop the branching nodes
        for (itBranching.first(); !itBranching.isDone(); itBranching.next())
        {
            // We skip already visited nodes.
            if (marker.isMarked (*itBranching))  { continue; }

            // We launch the breadth first search; we get as a result the set of branching nodes in this component
            const set<BranchingNode>& component = bfs.run (*itBranching);

            // We memorize the component
            components.push_back (component);

            // We mark the nodes for this connected component
            marker.mark (component);

            // We update our distribution
            distrib[component.size()] ++;
        }

        ti.stop ("compute");

        // We compute the total number of branching nodes in all connected components.
        size_t sum = 0;   for (map<size_t,size_t>::iterator it = distrib.begin(); it != distrib.end(); it++)  {  sum += it->first*it->second; }

        // Note: it must be equal to the number of branching nodes of the graph
        assert (sum == itBranching.size());

        size_t idx1=0;
        size_t cc=0;
        // We check that each component has no intersection with all other components.
        // Note: this check may take a long time since we have N^2 intersections to compute.
        for (list<set<BranchingNode> >::iterator it1 = components.begin(); it1 != components.end(); it1++, idx1++)
        {
            size_t idx2=0;

            for (list<set<BranchingNode> >::iterator it2 = components.begin(); it2 != components.end(); it2++, idx2++)
            {
                if (it1 != it2)
                {
                    set<BranchingNode> inter;
                    set_intersection (it1->begin(),it1->end(),it2->begin(),it2->end(), std::inserter(inter,inter.begin()));
                    if (inter.size()!=0)  { printf ("ERROR, intersection should be empty...\n");  exit(EXIT_FAILURE); }
                }

                if (++cc % 50 == 0)
                {
                    cc = 0;
                    printf ("[check] %.1f  %.1f\r", 100.0*(float)idx1/(float)components.size(), 100.0*(float)idx2/(float)components.size());
                    fflush (stdout);
                }
            }
        }
        printf ("\n");

        // We aggregate the computed information
        Properties props ("connected_components");
        props.add (1, "graph_name",              "%s", graph.getName().c_str());
        props.add (1, "nb_branching_nodes",      "%d", sum);
        props.add (1, "nb_connected_components", "%d", distrib.size());
        for (map<size_t,size_t>::iterator it = distrib.begin(); it!=distrib.end(); it++)
        {
            props.add (2, "component");
            props.add (3, "nb_nodes",    "%d", it->first);
            props.add (3, "nb_occurs",   "%d", it->second);
            props.add (3, "freq_nodes",  "%f", 100.0*(float)(it->first*it->second) / (float)sum);
            props.add (3, "freq_occurs", "%f", 100.0*(float)it->second / (float)sum);
        }
        props.add (1, ti.getProperties("time"));

        // We dump the results in a XML file in the current directory
        XmlDumpPropertiesVisitor v (graph.getName() + ".xml", false);
        props.accept (&v);
    }
    catch (OptionFailure& e)
    {
        return e.displayErrors (std::cout);
    }
    catch (Exception& e)
    {
        std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
    }

    return EXIT_SUCCESS;
}
Beispiel #8
0
void MyStrategy::move(const Car& self, const World& world, const Game& game, Move& move) {
    if (!inited) {
        inited = true;

        gr = ToGrid(world.getTilesXY());
        gr = gr.Transposed();
        ::grid << gr;
        for (auto& w : world.getWaypoints()) {
            tiles << "col: " << w[0] << " row: " << w[1] << endl;
            waypoints.emplace_back(w[1], w[0]);
        }
        auto is_neighbor = [&](const Position& p, grid::Direction d) {
            return neighbors[static_cast<int>(gr[p])][d];
        };
        // shouldn't use grid at all here... or push values inside is_neighbor
        // but there maybe some cool logic
        BFS<TileType, decltype(is_neighbor)> bfs;
        bfs.Init(gr, is_neighbor);


        bfs.FindShortestPaths({14,2}, {13,13});

        for (int i = 0; i < world.getWaypoints().size(); ++i) {
            int i_next = (i+1) % world.getWaypoints().size();
            auto res = bfs.FindShortestPaths(waypoints[i], waypoints[i_next]);
            ways << waypoints[i] << "; " << waypoints[i_next] << endl;
            for (auto r : res) {
                for (auto p : r) {
                    ways << p << "; ";
                }
                ways << endl;
            }
            ways << endl;
        }

    }





    Position next_tile{self.getNextWaypointY(), self.getNextWaypointX()};

    Point target;
    target.x = (next_tile.col + 0.5) * game.getTrackTileSize();
    target.y = (next_tile.row + 0.5) * game.getTrackTileSize();
//   if (next_tile.ManhattanDistance(currentTile(self)) <= 2) {
    switch (world.getTilesXY()[next_tile.col][next_tile.row]) {
    case LEFT_TOP_CORNER:
        target.x += game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3;
        target.y += game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3;
//            nextWaypointX += cornerTileOffset;
//            nextWaypointY += cornerTileOffset;
        break;
    case RIGHT_TOP_CORNER:
        target.x -= (game.getTrackTileSize()/2 - game.getTrackTileMargin()  - self.getWidth()/3);
        target.y += game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3;


//            nextWaypointX -= cornerTileOffset;
//            nextWaypointY += cornerTileOffset;
        break;
    case LEFT_BOTTOM_CORNER:
        target.x += game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3;
        target.y -= (game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3);

//            nextWaypointX += cornerTileOffset;
//            nextWaypointY -= cornerTileOffset;
        break;
    case RIGHT_BOTTOM_CORNER:
        target.x -= (game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3);
        target.y -= (game.getTrackTileSize()/2 - game.getTrackTileMargin() - self.getWidth()/3);

//            nextWaypointX -= cornerTileOffset;
//            nextWaypointY -= cornerTileOffset;
        break;
    case RIGHT_HEADED_T:
        break;
    case LEFT_HEADED_T:
        break;
    case TOP_HEADED_T:
        break;
    case BOTTOM_HEADED_T:
        break;
    case CROSSROADS:
        break;
    default:
        break;
    }
//   }
    double angleToWaypoint = self.getAngleTo(target.x, target.y);
    double speedModule = hypot(self.getSpeedX(), self.getSpeedY());

    move.setWheelTurn(angleToWaypoint * 100. / PI);
    move.setEnginePower(1.);

    if (speedModule != prevSpeed) {
        stats << speedModule << endl;
    }
    prevSpeed = speedModule;
    if (speedModule * speedModule * abs(angleToWaypoint) > 2.5 * 2.5 * PI || speedModule > 30 ) {
        move.setBrake(true);
    }
}