IGraph *  Sequencer::buildGraph(std::vector<std::string>& reads){
    IGraph * graph = new Graph();
    graph->insertVertex(reads.at(0));
    for(int i = int(reads.size() - 1);i>0 ; i-- ){
        for(int j = i-1; j>=0; j--){
            if( reads.at(i).compare(reads.at(j)) == 0){
                break;
            }
            if(j == 0){
                graph->insertVertex(reads.at(i));
            }
        }
    } 

    std::vector<IVertex *> graph_vertices = graph->getVertices();
    int size_graph_vertices = graph_vertices.size();
    int max_overlap = 0;
    for(int i=0; i< size_graph_vertices; i++){
       for(int j=0; j< size_graph_vertices; j++){
            //find overlap
            if(i != j){
                int overlap = 0;
                for(int k = 0; k< graph_vertices.at(i)->getName().size(); k++){
                    int l = 0;
                    int count = 0;
                    int m = k;
                    while( graph_vertices.at(i)->getName()[m] == graph_vertices.at(j)->getName()[l] ){
                       m++;
                       l++; 
                       count++;
                    }   
                   if(count > overlap){
                        overlap = count;
                    }
                }
            if(max_overlap < overlap){
               max_overlap = overlap; 
            }
            if(overlap>0){
            IEdge *edge = new Edge();
            edge->setTarget(graph_vertices.at(j));
            edge->setWeight(overlap);
            graph_vertices.at(i)->addEdge(edge);
            }
            }
        } 
    }

    for(int i=0; i< size_graph_vertices; i++){
       IVertex* vert = graph_vertices.at(i);
       for(int j =0; j < vert->getEdges().size(); j++){
            IEdge * edg = vert->getEdges()[j];
            int wt = max_overlap - edg->getWeight();
            edg->setWeight(max_overlap - edg->getWeight());
        }     
    }
    return graph;
}
/**
 * O(V + Vlog(V) + Elog(V))
 * @param G [description]
 * @param s [description]
 */
void MST_prim(IGraph &G, IGraph::vertex &s, double inf = 1e100){
	int n = G.numVertices();
	bool *isQ = new bool[n];
	IGraph::vertex ** pi = new IGraph::vertex *[n];

	typedef pair<double, int> vi;
	
 	vector<vi> vertices;

 	IndexedPriorityQueue<double, less<double> > Q(n);

	for (int i = 0; i < n; ++i)
	{
		vertices.push_back(make_pair(inf, i));
		Q.insert(i, inf);
		pi[i] = NULL;
		isQ[i] = true;
	}

	vertices[s.id].first = 0;
	Q.changeKey(s.id, 0);

	int it = 0;
	while(!Q.isEmpty()){

		int id = Q.minIndex(); // O(1)
		Q.deleteMin(); // O(lg(v))

		cout << id << endl;

		isQ[id] = false;
		IGraph::vertex *u = G.getVertex(id);
		for (IGraph::vertex::iterator v = u->begin(); v != u->end(); ++v)
		{
			double w = G.getEdge(id, v->second->id);
			if(isQ[v->second->id] &&  w < vertices[v->second->id].first){// O(1)
				pi[v->second->id] = u;
				Q.changeKey(v->second->id, w); // O(log(v))
				vertices[v->second->id].first = w;
			}
		}

	}

	cout << "PRIMs : ";
	for (int i = 0; i < n; ++i)
	{
		if(pi[i] != NULL)
			cout << pi[i]->id << " ";
		else
			cout << "nil ";
	}
	cout << endl;

	delete [] isQ;

}
/**
 * O(V + E)
 * @param G  Graph
 * @param s source vertex
 */
void BFS(IGraph &G, IGraph::vertex &s){
	
	int n = G.numVertices();
	int *color = new int[n];
	int *d = new int[n];
	IGraph::vertex **pi = new IGraph::vertex*[n];
	
	for (IGraph::vertex_iterator v = G.begin(); v != G.end(); ++v)
	{
		color[v->id] = WHITE;
		pi[v->id] = NULL;
		d[v->id] = 1000000;
	}

	color[s.id] = GRAY;
	d[s.id] = 0;

	queue<IGraph::vertex * > Q;
	Q.push(&s); 
	while(!Q.empty()){

		IGraph::vertex * u = Q.front();
		for (IGraph::vertex::iterator e = u->begin(); e != u->end(); e++)
		{
			IGraph::vertex * v = e->second;	
			if(color[v->id] == WHITE){
				color[v->id] = GRAY;
				d[v->id] = d[u->id] + 1;
				pi[v->id] = u;
				Q.push(&(*v)); 
			}
		}
		color[u->id] = BLACK;
		Q.pop();
	}

	cout << "S : " << s.id << endl;
	for (int i = 0; i < n; ++i)
	{
		if(pi[i] != NULL)
			cout << pi[i]->id << " ";
		else
			cout << "nil ";
	}
	cout << endl;

	delete [] color;
	delete [] d;
	delete [] pi;
}
void complete2Tournament(IGraph &comp, IGraph &tour, bool unweighted = true){

	//if(comp.isComplete()){
	//	cout << "complete2Tournament" << endl;
		for (IGraph::vertex_iterator v = comp.begin(); v != comp.end(); v++){
			IGraph::vertex::iterator end = v->end();
			for (IGraph::vertex::iterator u = v->begin(); u != end; u++){
				if(!(tour.edgeExists(v->id,u->second->id) || tour.edgeExists(u->second->id, v->id))){
					double w1 = comp.getEdge(v->id, u->second->id);
					double w2 = comp.getEdge(u->second->id, v->id);
					
					double wVal = (unweighted)? 1 : abs(w1 - w2); 

					if(w1 > w2)
						tour.addEdge(v->id, u->second->id, (unweighted)? 1 : w1);
					else if(w1 < w2)
						tour.addEdge(u->second->id, v->id, (unweighted)? 1 : w2);
					else{
						tour.addEdge(u->second->id, v->id, (unweighted)? 1 : w2);
						tour.addEdge(v->id, u->second->id, (unweighted)? 1 : w1);
					}
				}
			}
		}
	//}
}
Exemple #5
0
void assertValidCover(IGraph *graph, vector<Node*> cover) {
    IGraph *g = new Graph(graph);
    for (Node *node : cover) {
        g->removeNode(node);
    }
    if (g->nbEdges() == 0) {
        rlutil::setColor(2);
        cout << "OK" << endl;
        rlutil::setColor(7);
    } else {
        rlutil::setColor(12);
        cout << "FAILED :  The provided cover is not a valid solution." << endl;
        rlutil::setColor(7);
    }
    delete g;
}
int tour_ham_merge_and_count(IGraph &tour, int *A, int *buffer, int ini, int fim, int meio){

	memset(buffer, 0, sizeof(int)*(fim-ini+1));

	int count = 0;

	int i = ini;
	int j = meio + 1;
	
	int k = 0;
	while(i < meio + 1 && j <= fim){
		if(tour.edgeExists(A[i], A[j])){
			buffer[k] = A[i];
			i++;
		}else{
			buffer[k] = A[j];
			count += meio - i + 1;
			j++;
		}
		k++;
	}

	if(i < meio + 1){
		memcpy(buffer + k, A + i, sizeof(int)*(meio-i+1));
	}else{
		memcpy(buffer + k, A + j, sizeof(int)*(fim-j+1));
	}
	
	memcpy(A + ini, buffer, sizeof(int)*(fim-ini+1));

	return count;
}
void DFSImplementation (const IGraph& graph, Visitor& visitor, std::vector<bool>& visited, int vertex_start) {
    std::stack <int> vertices_stack;
    vertices_stack.push(vertex_start);
    
    while (!vertices_stack.empty()) {
        int current_vertex = vertices_stack.top();
	
	if (!visited[current_vertex]) {
	    visited[current_vertex] = true;
	    visitor.StartProcessingVertex(current_vertex);

            std::vector<int> current_vertex_incidences = graph.GetIncidenceList(current_vertex);

            for (int i = 0; i < current_vertex_incidences.size(); ++i) {
                int next_incident_vertex = current_vertex_incidences[i];
	        visitor.ProcessingEdge(current_vertex, next_incident_vertex);
	        if (!visited[next_incident_vertex]) vertices_stack.push(next_incident_vertex);     
            }
	}
	else {
	    visitor.LeaveVertex(current_vertex);
	    vertices_stack.pop();
	}
    }
}     if (!visited[vertex]) DFSImplementation(graph, visitor, visited, vertex);
/**
 * complexity : O(V + E)
 * @param G Graph
 * @param s source vertex
 */
void DFS(IGraph &G, IGraph::vertex &s){

	int n = G.numVertices();
	int *color = new int[n];
	int *d = new int[n];
	int *f = new int[n];
	IGraph::vertex **pi = new IGraph::vertex*[n];
	
	for (IGraph::vertex_iterator v = G.begin(); v != G.end(); ++v)
	{
		color[v->id] = WHITE;
		pi[v->id] = NULL;
		d[v->id] = 0;
		f[v->id] = 0;
	}

	int dtime = 0;

	DFS_visit(G, s, color, d, f, pi, dtime);
	for (IGraph::vertex_iterator v = G.begin(); v != G.end(); ++v)
	{
		if(color[v->id] == WHITE){
			DFS_visit(G, *v, color, d, f, pi, dtime);
		}
	}

	cout << "S : " << s.id << endl;
	for (int i = 0; i < n; ++i)
	{
		if(pi[i] != NULL)
			cout << pi[i]->id << "(" << d[i] << "/" << f[i] <<  ") ";
		else
			cout << "nil" << "(" << d[i] << "/" << f[i] <<  ") ";
	}
	cout << endl;

	delete [] color;
	delete [] d;
	delete [] f;
	delete [] pi;
}
	void FAS_pivot(IGraph &graph, std::vector<int> &vertices){
		
		if(vertices.size() <= 1) return;
		// pick random pivot
		int i = vertices[rand()%(vertices.size())];
		
		std::vector<int> vL;
		std::vector<int> vR;
		
		for (int j = 0; j < vertices.size(); ++j)
		{
			if(i == vertices[j]) continue;

			if(graph.edgeExists(vertices[j], i)){
				vL.push_back(vertices[j]);
			}else if(graph.edgeExists(i, vertices[j])){
				vR.push_back(vertices[j]);
			}
		}
		
		FAS_pivot(graph, vL);
		FAS_pivot(graph, vR);
		
		vertices.clear();
		for (int k = 0; k < vL.size(); ++k)
		{
			vertices.push_back(vL[k]);
		}

		vertices.push_back(i);

		for (int k = 0; k < vR.size(); ++k)
		{
			vertices.push_back(vR[k]);
		}

	}
inline void TestIGraphHasEdge(const IGraph& graph, const std::vector<Edge> &list_of_edges,
                              int vertex_a, int vertex_b) {

    bool has_edge_between_a_and_b = graph.HasEdge(vertex_a, vertex_b);
    bool right_has_edge_between_a_and_b = false;

    for (int edge_index = 0; edge_index < list_of_edges.size(); ++edge_index) {
        if (list_of_edges[edge_index].begin_ == vertex_a && list_of_edges[edge_index].end_ == vertex_b) {
            right_has_edge_between_a_and_b = true;
            break;
        }
    }

    if (right_has_edge_between_a_and_b != has_edge_between_a_and_b) {
        throw std::logic_error("TestIGraphHasEdge: FAIL");
    }
}
inline void TestIGraphGetIncidenceList(const IGraph& graph, const std::vector<Edge> &list_of_edges, int vertex) {

    std::unordered_set<int> right_insidence_vertices_set;


    std::vector<int> incidence_list = graph.GetIncidenceList(vertex);
    std::unordered_set<int> incidence_vertices_set(incidence_list.begin(), incidence_list.end());

    for (int edge_index = 0; edge_index < list_of_edges.size(); ++edge_index) {
        if (list_of_edges[edge_index].begin_ == vertex) {
            right_insidence_vertices_set.insert(list_of_edges[edge_index].end_);
        }
    }

    if (incidence_vertices_set != right_insidence_vertices_set) {
        throw std::logic_error("IGraph::GetIncidenceList : FAIL");
    }

}
void DVhamiltonPathForTournament(IGraph &tour, int * path){
	int * buffer = new int[tour.numVertices()];

	tour_ham_sort_and_count(tour, path, buffer, 0, tour.numVertices() - 1);
}
inline void TestIGraphGetNumberOfVertices (const IGraph& graph, int vertices_amount) {
    if (graph.GetNumberOfVertices() != vertices_amount) {
        throw std::logic_error("IGraph::GetNumberOfVertices: FAIL");
    }
}
Exemple #14
0
/*!
 * \brief Calback function invoking layout algorithms from Dia's menu
 * \ingroup LayoutPlugin
 */
static ObjectChange *
layout_callback (DiagramData *data,
                 const gchar *filename,
                 guint flags, /* further additions */
                 void *user_data,
		 GraphCreateFunc func)
{
  ObjectChange *changes = NULL;
  GList *nodes = NULL, *edges = NULL, *list;
  const char *algorithm = (const char*)user_data;

  /* from the selection create two lists */
  list = data_get_sorted_selected (data);
  while (list) {
    DiaObject *o = (DiaObject *)list->data;
    if (!maybe_edge (o))
      nodes = g_list_append (nodes, o);
    //FIXME: neither 1 nor num_handles-1 is guaranteed to be the second connection
    // it entirely depends on the objects implementation
    else if (   o->num_handles > 1 && o->handles[0]->connected_to 
             && (o->handles[1]->connected_to || o->handles[o->num_handles-1]->connected_to))
      edges = g_list_append (edges, o);
    list = g_list_next(list);
  }
  if (g_list_length (edges) < 1 || g_list_length (nodes) < 2) {
    message_warning (_("Please select edges and nodes to layout."));
  } else {
    IGraph *g = func ? func () : NULL;

    if (!g)
      message_error (_("Graph creation failed"));
    else {
      std::vector<double> coords;

      /* transfer nodes and edges */
      for (list = nodes; list != NULL; list = g_list_next(list)) {
        DiaObject *o = (DiaObject *)list->data;
        const Rectangle *bbox = dia_object_get_bounding_box (o);
        g->AddNode (bbox->left, bbox->top, bbox->right, bbox->bottom);
      }
      for (list = edges; list != NULL; list = g_list_next(list)) {
        DiaObject *o = (DiaObject *)list->data;
	DiaObject *src = o->handles[0]->connected_to->object;
	// see above: there is no guarantee ...
	DiaObject *dst = o->handles[1]->connected_to ?
	  o->handles[1]->connected_to->object : o->handles[o->num_handles-1]->connected_to->object;

	if (_obj_get_bends (o, coords))
          g->AddEdge (g_list_index (nodes, src), g_list_index (nodes, dst), &coords[0], coords.size());
	else
          g->AddEdge (g_list_index (nodes, src), g_list_index (nodes, dst), NULL, 0);
      }
      IGraph::eResult res;
      if ((res = g->Layout (algorithm)) != IGraph::SUCCESS) {
	const char *sErr;
	switch (res) {
	case IGraph::NO_MODULE : sErr = _("No such module."); break;
	case IGraph::OUT_OF_MEMORY : sErr = _("Out of memory."); break;
	case IGraph::NO_TREE: sErr = _("Not a tree."); break;
	case IGraph::NO_FOREST: sErr = _("Not a forest."); break;
	case IGraph::FAILED_ALGORITHM: sErr = _("Failed algorithm."); break;
	case IGraph::FAILED_PRECONDITION: sErr = _("Failed precondition."); break;
	case IGraph::CRASHED : sErr = _("OGDF crashed."); break;
	default : sErr = _("Unknown reason"); break;
	}
        message_warning (_("Layout '%s' failed.\n%s"), (const char*)user_data, sErr);
      } else {
        changes = change_list_create ();
	/* transfer back information */
	int n;
	for (n = 0, list = nodes; list != NULL; list = g_list_next (list), ++n) {
	  Point pt;
	  if (g->GetNodePosition (n, &pt.x, &pt.y)) {
	    DiaObject *o = (DiaObject *)list->data;
	    GPtrArray *props = g_ptr_array_new ();
	    
	    //FIXME: can't use "obj_pos", it is not read in usual update_data impementations
	    // "elem_corner" will only work for Element derived classes, but that covers most
	    // of the cases here ...
	    prop_list_add_point (props, "elem_corner", &pt);
	    change_list_add (changes, object_apply_props (o, props));
	  }
	}
	// first update to reuse the connected points
	diagram_update_connections_selection(DIA_DIAGRAM (data));
	/* use edge bends, if any */
	int e;
	for (e = 0, list = edges; list != NULL; list = g_list_next (list), ++e) {
          DiaObject *o = (DiaObject *)list->data;
	  // number of bends / 2 is the number of points
	  int n = g->GetEdgeBends (e, NULL, 0);
	  if (n >= 0) { // with 0 it is just a reset of the exisiting line
	    try {
	      coords.resize (n);
	    } catch (std::bad_alloc& ex) {
	      g_warning ("%s", ex.what());
	      continue;
	    }
	    g->GetEdgeBends (e, &coords[0], n);
	    change_list_add (changes, _obj_set_bends (o, coords));
	  }
	}
	/* update view */
	diagram_update_connections_selection(DIA_DIAGRAM (data));
      }
      g->Release ();
    }
  }
  g_list_free (nodes);
  g_list_free (edges);

  return changes;
}
void DFS (const IGraph& graph, Visitor& visitor) {
    std::vector<bool> visited(graph.GetNumberOfVertices(), false);
    for (int vertex = 0; vertex < graph.GetNumberOfVertices(); ++vertex) 
        if (!visited[vertex]) DFSImplementation(graph, visitor, visited, vertex);
}