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

int mincut::check (graph& G) 
{
	if (!set_vars_executed)
    {
		return(GTL_ERROR);
    }
    if ((G.number_of_nodes() <= 1) || (!G.is_connected()) || (G.is_directed()))
    {
		return(GTL_ERROR);
    }
    return GTL_OK;
}

__GTL_BEGIN_NAMESPACE

pathfinder::pathfinder (const graph& G, edge st, node s) 
{
    node t = s.opposite (st);
    dfs_num.init (G, 0);
    low_num.init (G);
    tree.init (G, list<edge>());
    back.init (G, list<edge>());
    forward.init (G, list<edge>());

    //
    // There is a problem with node/edge maps of iterators with Visual C++
    // which I don´t fully understand at the moment. Anyway the init for the 
    // maps below is only needed to allocate memory, which is done anyway, when
    // values are assigned to it.
    //
    
#ifndef __GTL_MSVCC	
    to_low.init (G);
    to_father.init (G);
    pos.init (G);
#endif
    
    used.init (G,0);
    act_dfs_num  = 1;
    new_nodes = G.number_of_nodes();
    is_biconn = true;
    
    //
    // Do DFS with biconnectivity extensions.
    //
    
    dfs_num[t] = act_dfs_num++;
    low_num[t] = dfs_num[t];
    new_nodes--;
	
    dfs_sub (s, t);
	
    if (new_nodes != 0) {
	is_biconn = false;
    } 
	
    used[t] = used[s] = 1;
}

void topsort::init_handler (graph& G) 
{
    top_numbers.init (G, 0);
    act_top_num = G.number_of_nodes();
}

int dijkstra::run(graph& G)
{
    init(G);

    less_dist prd(&dist, &mark);
    bin_heap<node, less_dist> node_heap(prd, G.number_of_nodes());
    mark[s] = grey;
    dist[s] = 0.0;
    node_heap.push(s);
    while (!node_heap.is_empty())
    {

	// debug:
	// node_heap.print_data_container();

	node cur_node = node_heap.top();
	node_heap.pop();

	// debug:
	// node_heap.print_data_container();

	mark[cur_node] = white;
	if (cur_node == t)
	{
	    // if @a t is set through #target we are ready
	    return GTL_OK;
	}

	node::adj_edges_iterator adj_edge_it;
	node::adj_edges_iterator adj_edges_end = cur_node.adj_edges_end();
	for (adj_edge_it = cur_node.adj_edges_begin();
	     adj_edge_it != adj_edges_end;
	     ++adj_edge_it)
	{
	    node op_node = (*adj_edge_it).opposite(cur_node);
	    if (mark[op_node] == black)
	    {
		mark[op_node] = grey;
		dist[op_node] = dist[cur_node] + weight[*adj_edge_it];
		node_heap.push(op_node);

		// debug:
		// node_heap.print_data_container();

		if (preds_set)
		{
		    pred[op_node] = *adj_edge_it;
		}
	    }
	    else if (mark[op_node] == grey)
	    {
		if (dist[op_node] > dist[cur_node] + weight[*adj_edge_it])
		{
		    dist[op_node] = dist[cur_node] + weight[*adj_edge_it];
		    node_heap.changeKey(op_node);

		    // debug:
		    // node_heap.print_data_container();

		    if (preds_set)
		    {
			pred[op_node] = *adj_edge_it;
		    }
		}
    	    }
	    else    // (mark[op_node] == white)
	    {
		// nothing to do: shortest distance to op_node is already
		//		  computed
	    }
	}
    }

    return GTL_OK;
}