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

void mbp_dijkstra(graph<key_type,graph_size> &g0, int s, int t,  vector< edge<key_type> > &path)
{
	struct adj_node<key_type>  table[graph_size + 1];
	key_type v_table[graph_size + 1];
	short v_flag[graph_size + 1];
	int v_parent[graph_size + 1];
	key_type v_parent_weight[graph_size + 1];
	vector<int> fringe;
	int i,max_v;
	struct adj_node<key_type>* temp;
	vector<int>::iterator ii,max,ed;
	//get all the edge information from the graph.
	g0.get_adj_table(table);
	for (i = 1; i <= graph_size ; i++) 
	{
		v_table[i] = 0;
		v_flag[i] = UNSEEN;
	}
	v_table[s] = MAX_WEIGHT + 1;
	v_flag[s] = FRINGE;
	fringe.push_back(s);
	while(fringe.size())
	{
		max = fringe.begin();
		ed = fringe.end();
		for (ii = fringe.begin(); ii != ed ; ii++) 
			if  ( v_table[*ii] > v_table[*max])  max = ii;
		max_v = *max;
		if (max_v == t) break;
		fringe.erase(max);
		v_flag[max_v] = INTREE;
		for(temp = table[max_v].adj_v;temp!=NULL;temp = temp->adj_v)
		{
			if (v_flag[temp->name] != INTREE) 
			{
				if (v_flag[temp->name] == UNSEEN) fringe.push_back(temp->name);
				v_flag[temp->name] = FRINGE;
				if ((temp->weight > v_table[temp->name]) && (v_table[max_v] >  v_table[temp->name]))
				{
					v_parent[temp->name] = max_v;
					v_parent_weight[temp->name] = temp->weight;
					v_table[temp->name] = std::min(v_table[max_v],temp->weight);
				}	
			}
		}
	}
	i = t;
	edge<key_type> edge_here;
	while( i != s) 
	{
		edge_here = edge<key_type>(v_parent[i],i,v_parent_weight[i]);
		path.push_back(edge_here);
		i = v_parent[i];
	}
	return;
}

void mbp_kruskal(graph<key_type,graph_size> &g0, int s, int t, vector< edge<key_type> > &path)
{
	int i,j,edge_num = 0;
	struct adj_node<key_type>  table[graph_size + 1];
	struct adj_node<key_type>*  tree_edges = table;
	edge<key_type> temp_e,tt;
	vector< edge<key_type> > edges;
	struct adj_node<key_type>* temp;
	int degree[graph_size + 1],set[graph_size + 1];
	//get all the edge information from the graph.
	g0.get_adj_table(table);
	edges.reserve((graph_size + 1) * (1+graph_size));
	heap<edge<key_type>,graph_size*graph_size,value_fun_edge<key_type>,name_fun_edge<key_type>,key_type> h0(false);
	for (i = 1 ; i <= graph_size; i ++ )
	{ 
		for(temp = table[i].adj_v;temp != NULL; temp = temp->adj_v)
		{
				temp_e = edge<key_type>(i,temp->name,temp->weight);
		// Here we use this code to guide the compiler generate conditonal move instruction, which can decrease the 
		// branch misprediction penalty. 
				edges[(temp->name > i) ? edge_num : 0] = temp_e;
				edge_num += (temp->name > i);
		}
	}
	for (i = 1 ; i <= edge_num; i ++ ) h0.insert(edges[i]);
	//make set for all the vertice
	for (i = 1 ; i <= graph_size ; i ++ ) make_set(set,degree,i);
	
	for (i = 1 ; i <= graph_size ; i ++ ) tree_edges[i].adj_v = NULL;
	long edge_count = 0;
	for(i = 0; i < edge_num ; i++ ) 
	{
		temp_e = h0.max();
		h0.del_max();
		if (find(set,temp_e.v1) != find(set,temp_e.v2) )
		{
			edge_count ++;
			set_union(set,degree,temp_e.v1,temp_e.v2);
			adj_node<key_type>* node1 = new adj_node<key_type>(temp_e.v1,temp_e.weight,tree_edges[temp_e.v2].adj_v);
			adj_node<key_type>* node2 = new adj_node<key_type>(temp_e.v2,temp_e.weight,tree_edges[temp_e.v1].adj_v);
			tree_edges[temp_e.v2].adj_v = node1;
			tree_edges[temp_e.v1].adj_v = node2;
		}
		if (edge_count == graph_size - 1 ) break;
	}
	bool v_flag[graph_size + 1];
	for (i = 1 ; i <= graph_size ; i ++ ) v_flag[i] = false;
	v_flag[s] = true;
	find_path<key_type,graph_size>(tree_edges,s,t,v_flag,path);
	return;
}

void mbp_dijkstra_heap(graph<key_type,graph_size> &g0, int s, int t,  vector< edge<key_type> > &path)
{
	struct adj_node<key_type>  table[graph_size + 1];
	short v_flag[graph_size + 1];
	int v_parent[graph_size + 1];
	key_type v_parent_weight[graph_size + 1];
	heap<vertex<key_type>,graph_size,value_fun<key_type>,name_fun<key_type>,key_type> fringe(true);
	vertex<key_type> max,v1;
	struct adj_node<key_type>* temp;
	g0.get_adj_table(table);
	for (int i = 1; i <= graph_size ; i++) v_flag[i] = UNSEEN;
	v1 = g0.get_v(s);
	v1.set_key(MAX_WEIGHT + 1);
	v_flag[s] = FRINGE;
	fringe.insert(v1);
	while(fringe.size())
	{
		max = fringe.max();
		if (max.get_name() == t) break;
		for(temp = table[max.get_name()].adj_v;temp!=NULL;temp = temp->adj_v)
				{
			if (v_flag[temp->name] != INTREE)
			{
				if (v_flag[temp->name] == UNSEEN) fringe.insert(g0.get_v(temp->name));
				v_flag[temp->name] = FRINGE;
				if ((temp->weight > (fringe.index(fringe.get_index(temp->name))).get_key() )
				&&  (max.get_key() > (fringe.index(fringe.get_index(temp->name))).get_key() ) )
				{
					v_parent[temp->name] = max.get_name();
					v_parent_weight[temp->name] = temp->weight;
					//Relax
					v1 = fringe.index(fringe.get_index(temp->name));
					v1.set_key(std::min(max.get_key(),temp->weight));
					fringe.modify_at(fringe.get_index(temp->name),v1);
				}	
			}
		}
		v_flag[max.get_name()] = INTREE;
		fringe.del_max();
	}
	int i = t;
	edge<key_type> edge_here;
	while( i != s) 
	{
		edge_here = edge<key_type>(v_parent[i],i,v_parent_weight[i]);
		path.push_back(edge_here);
		i = v_parent[i];
	}
	return;
}