C++ Vertices::empty方法代码示例

void expand(bool MCR, const bool * const * conn, Vertices &V) {
	int min_k;
	Vertices temp;
	size_t i;
	while(!V.empty()) {
		min_k = maxclique.size() > tmpclique.size() ? maxclique.size() - tmpclique.size() : -1;
		if(V.get_color_num() > min_k) {
			i = V.pop();
			tmpclique.push_back(i);
			temp.cut_vertex_from(conn, V, i);
			if(!temp.empty()) {
		//		temp.set_degrees(conn);
		//		MCR ? temp.MCR_sort(conn) : temp.degree_sort();
		//		temp.colo_sort(conn, min_k);
				num++;
				expand(MCR, conn, temp);
			}
			else if (tmpclique.size() > maxclique.size()) {
				std::cout<<"step = "<<num<<" current max size: "<<tmpclique.size()<<std::endl;
				maxclique = tmpclique;
			}
			tmpclique.pop_back();
		}
		else {
			return;
		}
	}
}

    void set_candidates_and_demands
    (const Graph& g, Vertices& candidates, Vertices& demands,
     ExistedCenterMap existed_center_map, CandidateMap candidate_map)
    {
      using boost::vertices;
      const typename boost::graph_traits<Graph>::vertices_size_type
        num_v = num_vertices(g);

      candidates.reserve(num_v);
      demands.reserve(num_v);

      typename boost::graph_traits<Graph>::vertex_iterator vi, vi_end;
      for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
        if (get(candidate_map, *vi) != false &&
            get(existed_center_map, *vi) == false) {
          candidates.push_back(*vi);
        }
        demands.push_back(*vi);
      }

      // TODO copy_if or filter_iterator
      //
      if (candidates.empty()) {
        throw std::runtime_error("The number of candidate vertex is too small");
      }
    }

bool Graph::isConnected (Vertices *V)
{
    Vertices *nextVertices = new Vertices();
    int reachedsize = 1;

    bool first = true;
    for (Vertices::iterator it = V->begin(); it != V->end(); ++it)
    {
		int v = *it;
		if (first)
		{
			nextVertices->insert(v);
			reachedVertices[v] = true;
			first = false;
		}
		else { reachedVertices[v] = false; }
    }

    while (!nextVertices->empty())
    {
		Vertices::iterator it = nextVertices->end(); --it;
		int currentVertex = *it;
		nextVertices->erase(it);
	
		Vertices *adjList = adjacencySets[currentVertex];
		for (Vertices::iterator it = adjList->begin(); it != adjList->end(); ++it) {
			int adjV = *it;
			if (V->find(adjV) != V->end())
			{
				if (!reachedVertices[adjV]) {
					reachedVertices[adjV] = true;
					reachedsize++;
					nextVertices->insert(adjV);
				}
			}
		}
    }
	
    delete nextVertices;
	
    return reachedsize == (int) V->size();
}

void MDAL::Driver3Di::populateFacesAndVertices( Vertices &vertices, Faces &faces )
{
  assert( vertices.empty() );
  size_t faceCount = mDimensions.size( CFDimensions::Face2D );
  faces.resize( faceCount );
  size_t verticesInFace = mDimensions.size( CFDimensions::MaxVerticesInFace );
  size_t arrsize = faceCount * verticesInFace;
  std::map<std::string, size_t> xyToVertex2DId;

  // X coordinate
  int ncidX = mNcFile.getVarId( "Mesh2DContour_x" );
  double fillX = mNcFile.getFillValue( ncidX );
  std::vector<double> faceVerticesX( arrsize );
  if ( nc_get_var_double( mNcFile.handle(), ncidX, faceVerticesX.data() ) ) throw MDAL_Status::Err_UnknownFormat;

  // Y coordinate
  int ncidY = mNcFile.getVarId( "Mesh2DContour_y" );
  double fillY = mNcFile.getFillValue( ncidY );
  std::vector<double> faceVerticesY( arrsize );
  if ( nc_get_var_double( mNcFile.handle(), ncidY, faceVerticesY.data() ) ) throw MDAL_Status::Err_UnknownFormat;

  // now populate create faces and backtrack which vertices
  // are used in multiple faces
  for ( size_t faceId = 0; faceId < faceCount; ++faceId )
  {
    Face face;

    for ( size_t faceVertexId = 0; faceVertexId < verticesInFace; ++faceVertexId )
    {
      size_t arrId = faceId * verticesInFace + faceVertexId;
      Vertex vertex;
      vertex.x = faceVerticesX[arrId];
      vertex.y = faceVerticesY[arrId];
      vertex.z = 0;

      if ( MDAL::equals( vertex.x, fillX ) || MDAL::equals( vertex.y, fillY ) )
        break;


      size_t vertexId;

      std::string key = std::to_string( vertex.x ) + "," + std::to_string( vertex.y );
      const auto it = xyToVertex2DId.find( key );
      if ( it == xyToVertex2DId.end() )
      {
        // new vertex
        vertexId = vertices.size();
        xyToVertex2DId[key] = vertexId;
        vertices.push_back( vertex );
      }
      else
      {
        // existing vertex
        vertexId = it->second;
      }

      face.push_back( vertexId );

    }

    faces[faceId] = face;
  }

  // Only now we have number of vertices, since we identified vertices that
  // are used in multiple faces
  mDimensions.setDimension( CFDimensions::Vertex2D, vertices.size() );
}

void Atoms::ComputeAtoms() {
    // Get minimal triangulation
    EliminationOrder* eo = new EliminationOrder(G_);
    FillEdges* F = new FillEdges(G_);
    VertexList* minsep_generators = new VertexList();
    MCSmPlus::Run(*G_, eo, F, minsep_generators);

    std::list< VertexSet* > vertices_of_atoms;
    SeparatorComponents cc(G_);
    Vertices deleted_vertices;  // in paper, this is V(G_) - V(G_')
    std::vector< bool > is_deleted(G_->order(), false);

    // Examine minsep_generators, eo-earliest first
    for (int i : *minsep_generators) {
        // Check to see if minimal separator is a clique
        Vertex v = eo->VertexAt(i);
        Vertices S;
        for (Vertex u : G_->N(v)) {
            if (eo->Before(v, u) && !is_deleted[u]) {
                S.push_back(u);
            }
        }
        for (Vertex u : (*F)[v]) {
            if (eo->Before(v, u) && !is_deleted[u]) {
                S.push_back(u);
            }
        }
        if (G_->IsClique(S)) {
            clique_minimal_separators_.Insert(S);
            for (Vertex u : deleted_vertices) {
                S.push_back(u);
            }
            cc.Separate(S);
            Vertices C = cc.ConnectedComponent(v);
            VertexSet* atom = new VertexSet();
            for (Vertex u : C) {
                if (!is_deleted[u]) {
                    deleted_vertices.push_back(u);
                    is_deleted[u] = true;
                    atom->insert(u);
                }
            }
            for (Vertex u : S) {
                if (!is_deleted[u]) {
                    atom->insert(u);
                }
            }
            vertices_of_atoms.push_back(atom);
        }
    }
    // Remaining vertices form an atom
    Vertices C;
    for (Vertex v : *G_) {
        if (!is_deleted[v]) {
            C.push_back(v);
        }
    }
    if (!C.empty()) {
        VertexSet* atom = new VertexSet();
        for (Vertex v : C) {
            atom->insert(v);
        }
        vertices_of_atoms.push_back(atom);
    }
    for (VertexSet* U : vertices_of_atoms) {
        atom_subgraphs_.push_back(new InducedSubgraph(G_, *U));
        delete U;
    }
    delete eo;
    delete F;
    delete minsep_generators;
    return;
}