inline std::map<std::string, typename boost::graph_traits<Graph>::vertex_descriptor>
read_graph(Graph& g, InputStream& is)
{
typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
typedef boost::null_property_map<Vertex, std::string> NameMap;
return read_graph(g, NameMap(), is);
}
int main(int argc,char *argv[])
{
read_graph(argv[1]);
printf("Main print\n");
print_graph();
int smallestOutDegree = smallestOutDegreeSearch(getAllNodeIndexs());
char *name = mygraph->table[smallestOutDegree].name;
int largestOutDegree = largestOutDegreeSearch(getAllNodeIndexs());
char *name1 = mygraph->table[largestOutDegree].name;
int smallestInDegree = smallestInDegreeSearch(getAllNodeIndexs());
char *name2 = mygraph->table[smallestInDegree].name;
int largestInDegree = largestInDegreeSearch(getAllNodeIndexs());
char *name3 = mygraph->table[largestInDegree].name;
printf("The smallest outdegree: %d \t Name: %s(%dth)\n"
, mygraph->table[smallestOutDegree].outdegree, name, smallestOutDegree);
printf("The largest outdegree: %d \t Name: %s(%dth)\n\n"
, mygraph->table[largestOutDegree].outdegree , name1, largestOutDegree);
printf("The smallest indegree: %d \t Name: %s(%dth)\n"
, mygraph->table[smallestInDegree].indegree , name2, smallestInDegree);
printf("The largest indegree: %d \t Name: %s(%dth)\n"
, mygraph->table[largestInDegree].indegree , name3, largestInDegree );
return(0);
}//main
int main()
{
graph g;
read_graph(&g, 0);
dijkstra(&g, 0);
print_graph(&g);
}
int main(int argc,char *argv[])
{
read_graph(argv[1]);
printf("\nPath Distance from %s to %s: %d\n", argv[2], argv[3], heuristicPathFinder(atoi(argv[2]), atoi(argv[3])));
return(0);
}
int main(void) {
graph g;
read_graph(&g, TRUE);
print_graph(&g);
strong_components(&g);
return 0;
}
struct roadmap *read_input(const char *input_filename){
struct buffer file_buf = read_input_into_buffer(input_filename);
if(file_buf.mem == NULL){
return NULL;
}
struct roadmap *map = read_graph(file_buf);
return map;
}
int main(void) {
graph g;
read_graph(&g, FALSE);
print_graph(&g);
articulation_vertices(&g);
return 0;
}
main()
{
graph g;
read_graph(&g,FALSE);
print_graph(&g);
connected_components(&g);
}
int main(int argc, char *argv[])
{
FILE *fp;
graph g;
int i;
int total_colors[] = {0, 0, 0};
int max, min;
if (argc != 2) {
fprintf(stderr, "Usage: %s filename\n", argv[0]);
exit(1);
}
fp = fopen(argv[1], "r");
if (fp == NULL) {
fprintf(stderr, "Can't open file %s\n", argv[1]);
exit(1);
}
read_graph(fp, &g, TRUE);
//print_graph(&g);
twocolor(&g);
for (i=1; i<=(g.nvertices); i++) {
//printf(" %d",color[i]);
switch (color[i]) {
case UNCOLORED:
total_colors[0]++;
break;
case WHITE:
total_colors[1]++;
break;
case BLACK:
total_colors[2]++;
break;
}
}
#ifdef DEBUG
printf("TOTAL: %d\n", g.nvertices);
printf("WHITE: %d\n", total_colors[1]);
printf("BLACK: %d\n", total_colors[2]);
printf("UNCOLORED: %d\n", total_colors[0]);
#endif
max = (total_colors[1] > total_colors[2]) ? total_colors[1] : total_colors[2];
min = (total_colors[1] > total_colors[2]) ? total_colors[2] : total_colors[1];
printf("%d %d\n", max, min);
return 0;
}
void init() //read all the needed input files
{
read_place_name();
read_place_belong();
read_tag();
read_Person_location();
read_study_org();
read_work_org();
read_org_location();
read_graph();
}
int
main(int argn, char *argv[])
{
graph_t g;
read_graph(&g, FALSE);
print_graph(&g);
dijkstra(&g, 0);
if(argn > 1) {
find_path(0, atoi(argv[1]));
}
}
main()
{
graph g;
int i;
read_graph(&g,FALSE);
dijkstra(&g,1);
for (i=1; i<=g.nvertices; i++)
find_path(1,i,parent);
printf("\n");
}
int main() {
int n_problems, vertex_id, max_flow;
t_node vertex;
read_graph();
initialize_preflow(graph, graph->vertexs[0]);
scanf("%d", &n_problems);
while (n_problems > 0) {
links_to_cut = -1;
reset_crit_points(graph);
if (read_problem(graph) == 0) { /* menos de 2 pontos criticos */
printf("0\n");
--n_problems;
continue;
}
for (vertex_id = 0; vertex_id < graph->max_vertex; ++vertex_id) {
vertex = graph->vertexs[vertex_id];
if (vertex->is_critical) {
max_flow = relabel_to_front(graph, vertex);
if (max_flow == 0) {
links_to_cut = 0;
break;
} else if (max_flow < links_to_cut || links_to_cut < 0) {
links_to_cut = max_flow;
}
}
}
--n_problems;
printf("%d\n", links_to_cut);
}
/*n_problems = read the problem line count
for each line (problem)
reset critic points
read_problem(); <- set the critic points
for each V in critics
maxflow = relabel_to_front()
if maxflow == 0
links_to_cut < 2;
break;
else if maxflow < links_to_cut
links_to_cut = maxflow
print links_to_cute*/
return 0;
}
int main()
{
int a[NMAX];
int i;
read_graph(&g, FALSE);
print_graph(&g);
for (i=1; i<=g.nvertices; ++i) {
printf("\nPaths from 1 to %d: ", i);
backtrack(a, 0, i);
}
return 0;
}
int main(int argc, char** argv) {
FILE *input = fopen(FNAME,"r");
graph* g = read_graph(input);
fclose(input);
int path_len;
ll_node* path = longest_path_da(g,&path_len);
print_path(path);
printf("%i\n",path_len);
/*
graph* f = flip(g);
ll_node* cyc = cycles(g);
print_graph(g);
printf("\n\n");
print_graph(f);
printf("\n\n");
cycle_counter counter = build_cycle_counter(cyc,g,f);
print_cycle_counter(counter);
init_cut_cycles(counter, g, f);
print_cycle_counter(counter);
print_graph(g);
printf("\n\n");
print_graph(f);
printf("\n\n");
inc_cycles(counter,g,f);
print_graph(g);
printf("\n\n");
print_graph(f);
*/
/*
print_cycle_counter(cycle_counter);
ll_node* cur = cyc;
while(cur != NULL) {
print_path(cur->data);
cur = cur->next;
}
free_ll(cyc);
free_graph(g);
free_graph(f);
*/
}
int RDFParser::read_rules(stringstream & stream) {
int ret=0;
string rulename;
string rulestr;
Rule * rule;
rdfg->graph->resolve();
while (ret >= 0) {
ret = check_str(stream, "rule");
if (ret<0)
break;
stream >> rulename;
rule = new Rule(rulename);
ret = read_str(stream, "{");
if (ret < 0)
return ret;
ret = read_str(stream, "left");
if (ret < 0)
return ret;
ret = read_graph(stream, rule->left());
if (ret < 0)
return ret;
ret = read_str(stream, "right");
if (ret < 0)
return ret;
ret = read_graph(stream, rule->right());
if (ret < 0)
return ret;
ret = read_str(stream, "}");
if (ret < 0)
return ret;
rule->preprocess();
rdfg->add_rule(rule);
}
return 0;
}
int main(int argc,char *argv[])
{
// define graph
Graph mygraph;
// read graph from command line argument
read_graph(&mygraph,argv[1]);
//print_graph(&mygraph);
// send graph to dfs function
DFS(&mygraph);
return(0);
}
void run_testcase()
{
int start_point;
graph g;
graph *graphptr = &g;
initialize_graph(graphptr, false);
read_graph(graphptr, false);
initialize_search(graphptr);
scanf("%d", &start_point);
init_distances(start_point);
bfs(graphptr, start_point);
print_distances(graphptr, start_point);
}
main()
{
graph g;
int out[MAXV];
int i;
read_graph(&g,TRUE);
print_graph(&g);
topsort(&g,out);
for (i=1; i<=g.nvertices; i++)
printf(" %d",out[i]);
printf("\n");
}
int main()
{
graph g;
int i;
read_graph(&g,FALSE);
print_graph(&g);
twocolor(&g);
printf("the color of nodes\n");
for (i=1; i<=(g.nvertices); i++)
printf("%d: %d\n", i, color[i]);
printf("\n");
return 0;
}
DNNModel *ff_dnn_load_model_tf(const char *model_filename)
{
DNNModel *model = NULL;
TFModel *tf_model = NULL;
TF_Buffer *graph_def;
TF_ImportGraphDefOptions *graph_opts;
model = av_malloc(sizeof(DNNModel));
if (!model){
return NULL;
}
tf_model = av_malloc(sizeof(TFModel));
if (!tf_model){
av_freep(&model);
return NULL;
}
tf_model->session = NULL;
tf_model->input_tensor = NULL;
tf_model->output_data = NULL;
graph_def = read_graph(model_filename);
if (!graph_def){
av_freep(&tf_model);
av_freep(&model);
return NULL;
}
tf_model->graph = TF_NewGraph();
tf_model->status = TF_NewStatus();
graph_opts = TF_NewImportGraphDefOptions();
TF_GraphImportGraphDef(tf_model->graph, graph_def, graph_opts, tf_model->status);
TF_DeleteImportGraphDefOptions(graph_opts);
TF_DeleteBuffer(graph_def);
if (TF_GetCode(tf_model->status) != TF_OK){
TF_DeleteGraph(tf_model->graph);
TF_DeleteStatus(tf_model->status);
av_freep(&tf_model);
av_freep(&model);
return NULL;
}
model->model = (void *)tf_model;
model->set_input_output = &set_input_output_tf;
return model;
}
void city_tour()
{
graph h;
edge *elist;
int nedge;
init_graph(&h);
h.read_node_attr = read_cityname;
h.write_node_attr = write_cityname;
h.read_edge_attr = read_distance;
h.write_edge_attr = write_distance;
if (read_graph(FILENAME, &h)) {
print_graph(stdout, &h);
elist = (edge *) malloc(sizeof(edge) * (number_of_nodes(&h) - 1));
nedge = mst_kruskal(&h, elist, get_distance);
}
}
main()
{
graph g;
int i;
read_graph(&g,FALSE);
print_graph(&g);
initialize_search(&g);
bfs(&g,1);
for (i=1; i<=g.nvertices; i++)
printf(" %d",parent[i]);
printf("\n");
for (i=1; i<=g.nvertices; i++)
find_path(1,i,parent);
printf("\n");
}
int main ( int argc, char *argv[] ){
int i,j,size=argc-2;
int* nums;
printf( "Called with %d elements\n", argc-2 );
if ( argc < 2 ){
printf( "usage: %s filename [elements]", argv[0] );
exit(1);
}
nums=calloc(size,sizeof(int));
for(i=0;i<size;i++)nums[i]=atoi(argv[i+2]);
read_graph(argv[1]);
int errors=0;
for(i=0;i<size-1;i++)
for(j=i+1;j<size;j++)
if(!has_edge(nums[i],nums[j]))
printf("Error[%d] doesn't contain, %d %d\n",++errors,nums[i],nums[j]);
if(!errors)printf("Checked!\n");
return 0;
}
int main(int argc, char** argv) {
bool is_valid = true;
if (argc < 2 || argc > 3) {
std::cerr << "Usage: " << argv[0] << " input.gr [input.td]" << std::endl;
std::cerr << std::endl;
std::cerr << "Validates syntactical and semantical correctness of .gr and .td files. If only a .gr file is given, it validates the syntactical correctness of that file." << std::endl;
exit(1);
}
tree_decomposition T;
graph g;
std::ifstream fin(argv[1]);
try {
read_graph(fin,g);
} catch (const std::invalid_argument& e) {
std::cerr << "Invalid format in " << argv[1] << ": " << e.what() << std::endl;
is_valid = false;
}
fin.close();
if(argc==3 && is_valid) {
fin.open(argv[2]);
try {
read_tree_decomposition(fin, T);
} catch (const std::invalid_argument& e) {
std::cerr << "Invalid format in " << argv[2] << ": " << e.what() << std::endl;
is_valid = false;
}
fin.close();
if (is_valid) {
is_valid = is_valid_decomposition(T,g);
}
}
if (is_valid) {
std::cerr << "valid" << std::endl;
return 0;
} else {
std::cerr << "invalid" << std::endl;
return 1;
}
}
int main(int argc , char * argv[])
{
// if(argc !=4 ){ printf("\nUSAGE : simuation graph_data car_data time_step");exit(0);}
GRAPH G;
CARS C;
EDGES E;
time_step =1;// atof(argv[3]);
read_graph(&G, "input");//argv[1]);
read_cars(&C, "car_input");//argv[2]);
print_graph(&G);
print_cars(&C);
init(&G,&C,&E);
// print_edges(&E);
printf(" \n time_step : %f\n",time_step);
start_simulation(&G,&C,&E);
print_collisons();
print_path_history(&C);
print_edge_history(&E);
return 1;
}
void read_graph_file(char *edgefile,
char *graphfile,
int *num_vertex,
NODES ***vertex,
int *num_edge,
EDGE ***edge)
{
FILE *fp;
FILE *fp1;
fp = ckopen(edgefile, "r");
fp1 = ckopen(graphfile, "r");
*vertex = (NODES **) ckalloc(MAX_NODES * sizeof(NODES *));
*edge = (EDGE **) ckalloc(MAX_EDGE * sizeof(EDGE *));
*num_vertex = read_graph(*vertex, *edge, num_edge, fp, fp1);
printf("Input graph ... done. %d vertices and %d edges.\n",
*num_vertex, *num_edge);
fclose(fp1);
fclose(fp);
}
int main()
{
graph g;
int i;
read_graph(&g, FALSE);
print_graph(&g);
initialize_search(&g);
bfs(&g, 1);
printf("nodes parents:\n");
for (i=1; i<=g.nvertices; ++i)
printf("%d: %d\n", i, parent[i]);
printf("\n");
printf("path from root to every node\n");
for (i=0; i<=g.nvertices; ++i)
find_path(1, i, parent);
printf("\n");
return 0;
}
int main(int argc, char* argv[])
{
/*
std::vector<std::thread> workers;
for (int i=0; i<9; ++i){
auto th = std::thread(&hello, i);
workers.push_back(std::move(th));
}
std::cout << "Hi from main\n" ;
std::for_each(workers.begin(),workers.end(), [](std::thread & th){th.join();});*/
read_graph(argv[1]);
return 0;
}
static int
bench(FibHeap<size_t, size_t> *pq,
const struct settings &settings)
{
int ret = 0;
size_t number_of_nodes;
vertex_t *graph = read_graph(settings.graph_file,
settings.max_generated_random_weight != 0,
settings.max_generated_random_weight,
number_of_nodes,
settings.seed);
/* Our initial node is graph[0]. */
graph[0].n = pq->push((size_t)0, (size_t)0);
graph[0].distance = 0;
struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
start_sssp(pq, graph);
clock_gettime(CLOCK_MONOTONIC, &end);
/* End benchmark. */
//verify_graph(graph, number_of_nodes);
print_graph(graph,
number_of_nodes,
settings.output_file);
const double elapsed = timediff_in_s(start, end);
fprintf(stdout, "%f", elapsed);
delete_graph(graph, number_of_nodes);
return ret;
}