C++ graph::mark方法代码示例

void prim(graph &g, graph &sf)
// from weighted graph g, set sf to minimum spanning forest
// finds the minimum cost edge from a marked node to an unmarked node and adds it
// loop through all nodes and if a node is not marked,
// start adding edges with it as start
{
    g.clearMark();
    
    for (int n = 0; n < g.numNodes(); n++)  // loop through all nodes
    {
        if (!g.isMarked(n))
        {
            g.mark(n);

            edgepair pair = getMinEdge(g);
    
            while (pair.i != NONE && pair.j != NONE)
            {
                // mark edge
                g.mark(pair.i, pair.j);
                g.mark(pair.j, pair.i);

                // add both edges to create undirected edge
                sf.addEdge(pair.i, pair.j, pair.cost);
                sf.addEdge(pair.j, pair.i, pair.cost);
    
                g.mark(pair.j);       // mark the unmarked node

                pair = getMinEdge(g); // get next edge
            }
        }
        // if node is marked, just continue
    }
}

void findMSF(graph &g, graph &sf, int start)
	// finds a minimum spanning tree in graph 'g'
{
	priority_queue<edge, vector<edge>, CompareEdge> pq;
	vector<int> lst = getNeighbors(start, g);

	// build our priority queue
	for (int i = 0; i < lst.size(); i++)
	{
		pq.push(g.getEdge(start, lst[i]));
		g.mark(start, lst[i]);
	}

	// visit the start node
	g.visit(start);

	int src, dst, w;
	edge top;

	while (!pq.empty())
	{
		top = pq.top();
		pq.pop();
		src = top.getSource();
		dst = top.getDest();
		w = top.getWeight();

		// add edges
		if (!sf.isEdge(src, dst))
		{
			sf.addEdge(src, dst, w);
			sf.addEdge(dst, src, w);

			// delete edges if we make a cycle
			if (isCyclic(sf))
			{
				sf.removeEdge(src, dst);
				sf.removeEdge(dst, src);
			}
			else
			{
				g.visit(src);
				lst = getNeighbors(dst, g);

				for (int i = 0; i < lst.size(); i++)
				{
					if (!g.isMarked(dst, lst[i]))
					{
						pq.push(g.getEdge(dst, lst[i]));
						g.mark(dst, lst[i]);
					}
				} // for
			} // else
		} // if
	} // while
} // findMSF

void recursiveDFS(int curId, int dstId, graph &g,
                  stack<int> &path, bool &done)
// depth first search that uses the mem stack to search the graph g
{

    if (curId == dstId)
    {
        done = true;
        path.push(curId);
    }
    else
    {
        g.mark(curId);
        g.visit(curId);

        vector<int> lst = getNeighbors(curId, g);

        while (!lst.empty())
        {
            int current =  lst.back();
            lst.pop_back();

            if (!g.isVisited(current))
            {
                recursiveDFS(current, dstId, g, path, done);
            }
            if (done)
                // if we found our node then construct our path
            {
                path.push(curId);
                break;
            }
        }
    }
}

void findCycle(int curr, int start, bool &found, graph &g)
	// checks for cycles in a graph
{
	g.mark(curr);

	vector<int> lst = getNeighbors(curr, g);

	for (int i = 0; i < lst.size(); i++)
	{
		if (start == lst[i])
		{
			continue;
		}
		if (g.isMarked(lst[i]))
		{
			found = true;
		}
		else if (!g.isVisited(lst[i]))
		{
			findCycle(lst[i], curr, found, g);
		}
	} // for

	g.unMark(curr);
	g.visit(curr);

} // findCycle

int getNumComponents(graph &g)
{
   g.clearMark();
   g.clearVisit();
   int numComponents = 0;
   queue<int> currentMoves;
   for (int n=0;n<g.numNodes();n++)
   {
      if (!g.isVisited(n))
      {  
         numComponents++;
         int nodeNumber=n;
         g.visit(nodeNumber);
         currentMoves.push(nodeNumber);
         while(currentMoves.size() > 0)
         {
            int currentNode = currentMoves.front();
            currentMoves.pop();
            //Populate a list of nodes that can be visited
            for (int i=0;i<g.numNodes();i++)
            {
               if (g.isEdge(currentNode,i) && !g.isVisited(i))
               {
                  g.mark(currentNode,i);
                  g.visit(i);
                  currentMoves.push(i);
               }
            }
         }
      }
   }
   return numComponents;
}

pqueue getEdges(graph &g)
// iterate through graph and construct a priority queue with minimum cost
// only add an edgepair for edge between marked node and unmarked node
{
    pqueue edges;
    for (int i = 0; i < g.numNodes(); i++)
    {
        g.mark(i);
        
        for (int j = 0; j < g.numNodes(); j++)
        {
            if (g.isMarked(i) && !g.isMarked(j) && g.isEdge(i, j))
            {
                edgepair pair = {i, j, g.getEdgeWeight(i, j)};
                edges.push(pair);
            }
        }
    }
    return edges;
}

void findSpanningForest(graph &g, graph &sf)
// Create a graph sf that contains a spanning forest on the graph g.  
{
   g.clearMark();
   g.clearVisit();
   numComponents=0;
   queue<int> currentMoves;
   for (int n=0;n<g.numNodes();n++)
   {
      if (!g.isVisited(n))
      {  
         numComponents++;
         int nodeNumber=n;
         g.visit(nodeNumber);
         currentMoves.push(nodeNumber);
         while(currentMoves.size() > 0)
         {
            int currentNode = currentMoves.front();
            currentMoves.pop();
   
            //Populate a list of nodes that can be visited
            for (int i=0;i<g.numNodes();i++)
            {
               if (g.isEdge(currentNode,i) && !g.isVisited(i))
               {
                  g.mark(currentNode,i);
                  sf.addEdge(currentNode,i);
                  sf.setEdgeWeight(currentNode, i, g.getEdgeWeight(currentNode, i));
                  g.visit(i);
                  currentMoves.push(i);
               }
            }
         }
      }
   }
}

void prim(graph &g, graph &sf)
// Given a weighted graph g, sets sf equal to a minimum spanning
// forest on g.  Uses Prim's algorithm.
{
	NodeWeight minWeight = 0;
	NodeWeight minR, minP;
	bool edgeFound;

	g.clearMark();

	for(int i=0; i<g.numNodes(); i++)
	{
		if(!g.isMarked(i))
		{
			g.mark(i);
			for(int j=0; j<g.numNodes()-1; j++)
			//start at i and grow a spanning tree untill no more can be added
			{
				edgeFound = false;
				minWeight = MaxEdgeWeight;

				for(int r=0; r<g.numNodes(); r++)
				{
					for(int p=0; p<g.numNodes(); p++)
					{
						if(g.isEdge(r,p) && g.isMarked(r) && !g.isMarked(p))
						{
							if(g.getEdgeWeight(r,p) < minWeight)
							{
								minWeight = g.getEdgeWeight(r,p);
								minR= r;
								minP= p;
								edgeFound = true;
							}
						}
					}
				}
				//if edge was found add it to the tree
				if(edgeFound)
				{
					g.mark(minR,minP);
					g.mark(minP, minR);
					g.mark(minP);
				}
			}
		 }
		}
	//add marked edges to spanning forest graph
	for(int i=0; i<g.numNodes(); i++)
	{
		for(int j=i+1; j<g.numNodes(); j++)
		{
			if(g.isEdge(i,j) && g.isMarked(i,j))
			{
				sf.addEdge(i,j,g.getEdgeWeight(i,j));
				sf.addEdge(j,i,g.getEdgeWeight(j,i));
				cout<<"adding edge "<< i << " "<< j << endl;
				cout<<"num edges: "<<sf.numEdges() << endl;
			}
		}
	}
}