C++ Graph::AddVertex方法代码示例

int main() {
  
  std::cout << "start" << std::endl;
  typedef DiGraphAdjMatrix<std::string, int> Graph;
  Graph g;
  Graph::VertexPtr s = g.AddVertex("s");
  Graph::VertexPtr v1 = g.AddVertex("v1");
  Graph::VertexPtr v2 = g.AddVertex("v2");
  Graph::VertexPtr v3 = g.AddVertex("v3");
  Graph::VertexPtr v4 = g.AddVertex("v4");
  Graph::VertexPtr v5 = g.AddVertex("v5");
  Graph::VertexPtr v6 = g.AddVertex("v6");
  Graph::VertexPtr v7 = g.AddVertex("v7");
  g.AddEdge(*s, *v1, 1);
  g.AddEdge(*s, *v2, 1);
  g.AddEdge(*s, *v3, 1);
  g.AddEdge(*v1, *v4, 1);
  g.AddEdge(*v1, *v5, 1);
  g.AddEdge(*v5, *v6, 1);
  g.AddEdge(*v6, *v7, 1);

  DepthFirstVertexIterator<std::string, int> dfi(g, *s);
  while (dfi.HasNext()) {
    std::cout << "v:" << dfi.Next()->GetValue() << std::endl;
  }
  
  return 0;
}

        Graph GeneratorWHEEL::DoGenerate(list<int> parameter)
        {
            int n = parameter.front();
            Graph result;

            Vertex* center = *(result.AddVertex());
            Coordinates centercoords(2, 0.0f);
            center->SetCoordinates(centercoords);

            Vertex* prev = NULL;
            Vertex* first = NULL;
            for(int i = 0; i < n; i++)
            {
                Vertex* v = *(result.AddVertex());

                Coordinates coords(2);
                coords[0] = -5 * cos(i * (2 * M_PI / n) + M_PI/2);
                coords[1] =  5 * sin(i * (2 * M_PI / n) + M_PI/2);
                v->SetCoordinates(coords);

                if(prev != NULL)
                    result.AddEdge(prev, v);
                else
                    first = v;

                result.AddEdge(v, center);
                prev = v;
            }

            if(prev != NULL && first != NULL)
                result.AddEdge(prev, first);

            return result;
        }

int main () {
	Graph myGraph;
	Vertex * root;
	cout << "Simply enter the input and press Ctrl + Z to send EOF command" << endl;
	for (string line; getline(std::cin, line);) {
        size_t found;
        if ((found = line.find(" ")) != string::npos) {
        	if (root != NULL) {
        		root = myGraph.AddVertex(line.substr(0,found));
        		myGraph.AddVertex(line.substr(found + 1, string::npos));
        	}
        	else {
        		myGraph.AddVertex(line.substr(0,found));
        		myGraph.AddVertex(line.substr(found + 1, string::npos));
        	}
        	myGraph.AddEdge(line.substr(0,found), line.substr(found + 1, string::npos));
        }
    }
    myGraph.PrintSolution();
	return 0;
}

    Graph* BuildQueryGraph(const Graph* gQuery, const Subgraph& subg)
    {
        typedef typename Graph::VertexProp VertexProp;
        typedef typename Graph::EdgeType Edge;
        typedef typename Graph::DirectedEdgeType DirectedEdge;
        int num_vertices = subg.VertexCount();
        std::map<uint64_t, uint64_t> norm_id_map;

        Graph* g = new Graph(num_vertices);
   
        for (Subgraph::VertexIterator it = subg.BeginVertexSet();
                it != subg.EndVertexSet(); it++) {
            uint64_t u = *it;
            std::map<uint64_t, uint64_t>::iterator id_map_it = norm_id_map.find(u);
            if (id_map_it == norm_id_map.end()) {
                uint64_t mapped_u = norm_id_map.size();
                norm_id_map[u] = mapped_u;
                const VertexProp& u_prop = 
                        gQuery->GetVertexProperty(u);
                g->AddVertex(mapped_u, u_prop);
            }
        }

        g->AllocateAdjacencyLists();
 
        for (Subgraph::EdgeIterator it = subg.BeginEdgeSet(); 
                it != subg.EndEdgeSet(); it++) {
            const dir_edge_t& dir_e = *it;
            DirectedEdge dir_edge;
            dir_edge.s = norm_id_map[dir_e.s];
            dir_edge.t = norm_id_map[dir_e.t];
            int num_edges;
            const Edge* edges = gQuery->Neighbors(dir_e.s, num_edges);
            for (int i = 0; i < num_edges; i++) {
                if (edges[i].dst == dir_e.t) {
                    dir_edge.type = edges[i].type;
                    dir_edge.edge_data = edges[i].edge_data;
                    break;
                }
            }
            g->AddEdge(dir_edge);
        }

        return g;
    }

// Алгоритм Джонсона с использованием алгоритма Дейкстры на самоорганизующейся куче
void Djonson_SelfOrganizationHeap(int** dist, Graph ADJ, int num_vert)
{
    Graph AdditionalGraph = ADJ;

    AdditionalGraph.AddVertex(ADJ.GetNumOfVertex() + 1);

    int* dist_Bellman_Ford = new int[AdditionalGraph.GetNumOfVertex()];// Он будет содержать значения не больше нуля

    for(int i = 0; i < AdditionalGraph.GetNumOfVertex() - 1; i++)
        AdditionalGraph.AddEdge(AdditionalGraph.GetNumOfVertex() - 1, i, 0);

    // Применяем Беллмана-Форда для графа с наличием отрицательных весов ребер
    if(Bellman_Ford(dist_Bellman_Ford, AdditionalGraph, AdditionalGraph.GetNumOfVertex(), AdditionalGraph.GetNumOfVertex() - 1))
    {
        for(ADJ.Reset(); !ADJ.IsEnd(); ADJ.GoNext())// Делаем неотрицательные веса для алгоритма Дейкстры
        {
            ADJ.SetWeightOfEdge(ADJ.GetCurrVertex(),
                ADJ.GetCurrEdge().vertB,
                ADJ.GetCurrEdge().weight + dist_Bellman_Ford[ADJ.GetCurrVertex()] - dist_Bellman_Ford[ADJ.GetCurrEdge().vertB]);
        }

        for(int i = 0; i < ADJ.GetNumOfVertex(); i++)
        {
            Dijkstra_SelfOrganizationHeap(dist[i], ADJ, ADJ.GetNumOfVertex(), i);
            for(int j = 0; j < ADJ.GetNumOfVertex(); j++)
                dist[i][j] = dist[i][j] + dist_Bellman_Ford[j] - dist_Bellman_Ford[i];
        }

        for(ADJ.Reset(); !ADJ.IsEnd(); ADJ.GoNext())// Обратно меняем веса на предыдущие у графа ADJ
        {
            ADJ.SetWeightOfEdge(ADJ.GetCurrVertex(),
                ADJ.GetCurrEdge().vertB,
                ADJ.GetCurrEdge().weight + dist_Bellman_Ford[ADJ.GetCurrEdge().vertB ] - dist_Bellman_Ford[ADJ.GetCurrVertex()]);
        }
    }
    else
        cout << "Graph contains a cycle of negative weight" << endl;
}

        Graph ImportFilterGML::Import(std::istream& is)
        {
            OpenGraphtheory::Import::GMLLexer l(is);
            GMLTreeNode* GMLTreeRoot = new GMLTreeNode;
            l.yylex(GMLTreeRoot);

            Graph result;
            map<int, Vertex*> VertexRegister;
            GMLValueNode* GraphNode = GetValue<GMLValueNode>(GMLTreeRoot, "GRAPH");
            if(GraphNode == NULL)
                throw "GML Document contains no top-level element \"graph\" with children";

            bool GraphDirected = false;
            GMLValueInt* directed = GetValue<GMLValueInt>(GraphNode->value, "DIRECTED");
            if(directed != NULL)
                GraphDirected = directed->value == 1;

            // Iterate Nodes
            for(list<pair<string, GMLValue*> >::iterator n = GraphNode->value->Children.begin(); n != GraphNode->value->Children.end(); n++)
            {
                string N = n->first;
                transform(N.begin(), N.end(), N.begin(), ::toupper);
                if(N != "NODE")
                    continue;
                GMLValueNode *NValue = dynamic_cast<GMLValueNode*>(n->second);
                if(NValue == NULL)
                    continue;

                GMLValueInt* id = GetValue<GMLValueInt>(NValue->value, "ID");
                if(id == NULL)
                    continue;
                if(VertexRegister.find(id->value) != VertexRegister.end())
                    throw "Multiple nodes with the same id";
                Vertex* v = *(result.AddVertex());
                VertexRegister[id->value] = v;

                GMLValueString* label = GetValue<GMLValueString>(NValue->value, "LABEL");
                if(label != NULL)
                    v->SetLabel(label->value);

                GMLValueNode* graphics = GetValue<GMLValueNode>(NValue->value, "GRAPHICS");
                if(graphics != NULL)
                {
                    vector<float> coordinates;

                    GMLValueFloat* xf = GetValue<GMLValueFloat>(graphics->value, "X");
                    GMLValueInt* xi = GetValue<GMLValueInt>(graphics->value, "X");
                    if(xf != NULL) coordinates.push_back(xf->value);
                    else if(xi != NULL) coordinates.push_back(xi->value);
                    else coordinates.push_back(0);

                    GMLValueFloat* yf = GetValue<GMLValueFloat>(graphics->value, "Y");
                    GMLValueInt* yi = GetValue<GMLValueInt>(graphics->value, "Y");
                    if(yf != NULL) coordinates.push_back(yf->value);
                    else if(yi != NULL) coordinates.push_back(yi->value);
                    else coordinates.push_back(0);

                    GMLValueFloat* zf = GetValue<GMLValueFloat>(graphics->value, "Z");
                    GMLValueInt* zi = GetValue<GMLValueInt>(graphics->value, "Z");
                    if(zf != NULL) coordinates.push_back(zf->value);
                    else if(zi != NULL) coordinates.push_back(zi->value);
                    // a third coordinate is not enforced

                    v->SetCoordinates(coordinates);

                    GMLValueFloat* wf = GetValue<GMLValueFloat>(graphics->value, "W");
                    GMLValueInt* wi = GetValue<GMLValueInt>(graphics->value, "W");
                    if(wf != NULL) v->SetWeight(wf->value);
                    else if(wi != NULL) v->SetWeight(wi->value);

                }

            }

            for(list<pair<string, GMLValue*> >::iterator e = GraphNode->value->Children.begin(); e != GraphNode->value->Children.end(); e++)
            {
                string E = e->first;
                transform(E.begin(), E.end(), E.begin(), ::toupper);
                if(E != "EDGE")
                    continue;
                GMLValueNode *EValue = dynamic_cast<GMLValueNode*>(e->second);
                if(EValue == NULL)
                    continue;

                GMLValueInt* source = GetValue<GMLValueInt>(EValue->value, "SOURCE");
                GMLValueInt* target = GetValue<GMLValueInt>(EValue->value, "TARGET");
                if(source == NULL || target == NULL)
                    continue;
                if(VertexRegister.find(source->value) == VertexRegister.end()
                || VertexRegister.find(target->value) == VertexRegister.end())
                    continue;

                bool Directed = GraphDirected;
                GMLValueNode* graphics = GetValue<GMLValueNode>(EValue->value, "GRAPHICS");
                if(graphics != NULL)
                {
                    GMLValueString* type = GetValue<GMLValueString>(graphics->value, "TYPE");
                    if(type != NULL)
                        Directed = type->value == "arc";
                }
//.........这里部分代码省略.........